Changelog: add entries for the SMPTE VC-2 decoder and encoder

Signed-off-by: Rostislav Pehlivanov <atomnuker@gmail.com>
2016-02-14 21:59:50 +00:00
97 changed files with 512 additions and 971 deletions
--- a/62
+++ b/62
@@ -1,67 +1,7 @@
 Entries are sorted chronologically from oldest to youngest within each release,
 releases are sorted from youngest to oldest.

-
-version 3.0.2:
- avcodec/ttaenc: Reallocate packet if its too small
- configure: build fix for P5600 with mips code restructuring
- mips: add support for R6
- pgssubdec: fix subpicture output colorspace and range
- avcodec/ac3dec: Reset SPX when switching from EAC3 to AC3
- avfilter/vf_drawtext: Check return code of load_glyph()
- avformat/mux: Check that deinit is set before calling it
- avcodec/takdec: add code that got somehow lost in process of REing
- avcodec/apedec: fix decoding of stereo files with one channel full of silence
- avcodec/avpacket: Fix off by 5 error
- avcodec/h264: Fix for H.264 configuration parsing
- avcodec/bmp_parser: Ensure remaining_size is not too small in startcode packet crossing corner case
- avcodec/pngdec: Fix alpha detection with skip_frame
- Changelog: Make formating consistent
- avfilter/src_movie: fix how we check for overflows with seek_point
- avcodec/j2kenc: Add attribution to OpenJPEG project:
-
-
-version 3.0.1:
- avcodec/libutvideodec: copy frame so it has reference counters when refcounted_frames is set
- avformat/rtpdec_jpeg: fix low contrast image on low quality setting
- avformat/mpegtsenc: Fix used service
- avformat/mpegtsenc: Keep track of the program for each service
- avformat/file: Add crypto to default whitelist
- avcodec/mjpegenc_common: Store approximate aspect if exact cannot be stored
- lavc/hevc: Allow arbitrary garbage in bytestream as long as at least one NAL unit is found.
- avcodec/resample: Remove disabled and faulty code
- indeo2: Fix banding artefacts
- indeo2data: K&R formatting cosmetics
- avformat/hlsenc: Fix passing options, regression since bc9a5965c815cf7fd998d8ce14a18b8e861dd9ce
- avutil/random_seed: Add the runtime in cycles of the main loop to the entropy pool
- avutil/channel_layout: AV_CH_LAYOUT_6POINT1_BACK not reachable in parsing
- avformat/concatdec: set safe mode to enabled instead of auto
- avformat/utils: fix dts from pts code in compute_pkt_fields() during ascending delay
- avformat/rtpenc: Fix integer overflow in NTP_TO_RTP_FORMAT
- avcodec/dca: clear X96 channels if nothing was decoded
- fate/aac: Increase fuzz from of fate-aac-pns-encode from 72 to 74 for Loongson
- avformat/cache: Fix memleak of tree entries
- lavf/mov: downgrade sidx errors to non-fatal warnings; fixes trac #5216
- lavf/mov: fix sidx with edit lists
- avcodec/mjpegdec: Fix decoding slightly odd progressive jpeg
- swscale/utils: Fix chrSrcHSubSample for GBRAP16
- swscale/input: Fix GBRAP16 input
- avutil/pixdesc: Make get_color_type() aware of CIE XYZ formats
- avcodec/h264: Execute error concealment before marking the frame as done.
- swscale/x86/output: Fix yuv2planeX_16* with unaligned destination
- swscale/x86/output: Move code into yuv2planeX_mainloop
- MAINTAINERS: add myself as an OS/2 maintainer
- libwebpenc_animencoder: print library messages in verbose log levels
- libwebpenc_animencoder: zero initialize the WebPAnimEncoderOptions struct
- configure: check for SEC_I_CONTEXT_EXPIRED before enabling SChannel
- lavf/http: Add httpproxy to the default protocol whitelist.
- doc/utils: fix typo for min() description
- ffserver&ffm: Fixed issues preventing ffserver write_index and files_size from being set correctly which was breaking ffserver streaming.
- postproc: fix unaligned access
- vc2enc: fix use of uninitialized variables in the rate control system, correctly zero out coefficient array padding
- aacenc: optimize encoding speed
- avcodec/diracdec: check bitstream size related fields for overflows
- avcodec/h264_slice: Check PPS more extensively when its not copied
+version <next>:


 version 3.0:
--- a/1
+++ b/1
@@ -564,7 +564,6 @@ Windows ICL                             Matthew Oliver
 ADI/Blackfin DSP                        Marc Hoffman
 Sparc                                   Roman Shaposhnik
 x86                                     Michael Niedermayer
-OS/2                                    KO Myung-Hun


 Releases
--- a/2
+++ b/2
@@ -1 +1 @@
-3.0.2
+2.8.git
--- a/15
+++ b/15
@@ -1,15 +0,0 @@
-
-              ┌─────────────────────────────────────────┐
-              │ RELEASE NOTES for FFmpeg 3.0 "Einstein" │
-              └─────────────────────────────────────────┘
-
-   The FFmpeg Project proudly presents FFmpeg 3.0 "Einstein", about 5
-   months after the release of FFmpeg 2.8.
-
-   A complete Changelog is available at the root of the project, and the
-   complete Git history on http://source.ffmpeg.org.
-
-   We hope you will like this release as much as we enjoyed working on it, and
-   as usual, if you have any questions about it, or any FFmpeg related topic,
-   feel free to join us on the #ffmpeg IRC channel (on irc.freenode.net) or ask
-   on the mailing-lists.
--- a/254
+++ b/254
@@ -913,25 +913,6 @@ void foo(void){ __asm__ volatile($code); }
 EOF
 }

-check_inline_asm_flags(){
-    log check_inline_asm_flags "$@"
-    name="$1"
-    code="$2"
-    flags=''
-    shift 2
-    while [ "$1" != "" ]; do
-      append flags $1
-      shift
-    done;
-    disable $name
-    cat > $TMPC <<EOF
-void foo(void){ __asm__ volatile($code); }
-EOF
-    log_file $TMPC
-    check_cmd $cc $CPPFLAGS $CFLAGS $flags "$@" $CC_C $(cc_o $TMPO) $TMPC &&
-    enable $name && add_cflags $flags && add_asflags $flags && add_ldflags $flags
-}
-
 check_insn(){
    log check_insn "$@"
    check_inline_asm ${1}_inline "\"$2\""
@@ -1676,7 +1657,6 @@ ARCH_EXT_LIST_ARM="
 ARCH_EXT_LIST_MIPS="
    mipsfpu
    mips32r2
-    mips32r5
    mips64r2
    mips32r6
    mips64r6
@@ -2170,11 +2150,10 @@ mipsfpu_deps="mips"
 mipsdsp_deps="mips"
 mipsdspr2_deps="mips"
 mips32r2_deps="mips"
-mips32r5_deps="mips"
 mips32r6_deps="mips"
 mips64r2_deps="mips"
 mips64r6_deps="mips"
-msa_deps="mipsfpu"
+msa_deps="mips"
 mmi_deps="mips"

 altivec_deps="ppc"
@@ -4174,90 +4153,118 @@ elif enabled mips; then

    cpuflags="-march=$cpu"

-    if [ "$cpu" != "generic" ]; then
-        disable mips32r2
-        disable mips32r5
-        disable mips64r2
-        disable mips32r6
-        disable mips64r6
-        disable loongson2
-        disable loongson3
-
-        case $cpu in
-            24kc|24kf*|24kec|34kc|1004kc|24kef*|34kf*|1004kf*|74kc|74kf)
-                enable mips32r2
-                disable msa
-            ;;
-            p5600|i6400)
-                disable mipsdsp
-                disable mipsdspr2
-            ;;
-            loongson*)
-                enable loongson2
-                enable loongson3
-                enable local_aligned_8 local_aligned_16 local_aligned_32
-                enable simd_align_16
-                enable fast_64bit
-                enable fast_clz
-                enable fast_cmov
-                enable fast_unaligned
-                disable aligned_stack
-                case $cpu in
-                    loongson3*)
-                        cpuflags="-march=loongson3a -mhard-float -fno-expensive-optimizations"
-                    ;;
-                    loongson2e)
-                        cpuflags="-march=loongson2e -mhard-float -fno-expensive-optimizations"
-                    ;;
-                    loongson2f)
-                        cpuflags="-march=loongson2f -mhard-float -fno-expensive-optimizations"
-                    ;;
-                esac
-            ;;
-            *)
-                # Unknown CPU. Disable everything.
-                warn "unknown CPU. Disabling all MIPS optimizations."
-                disable mipsfpu
-                disable mipsdsp
-                disable mipsdspr2
-                disable msa
-                disable mmi
-            ;;
-        esac
-
-        case $cpu in
-            24kc)
-                disable mipsfpu
-                disable mipsdsp
-                disable mipsdspr2
-            ;;
-            24kf*)
-                disable mipsdsp
-                disable mipsdspr2
-            ;;
-            24kec|34kc|1004kc)
-                disable mipsfpu
-                disable mipsdspr2
-            ;;
-            24kef*|34kf*|1004kf*)
-                disable mipsdspr2
-            ;;
-            74kc)
-                disable mipsfpu
-            ;;
-            p5600)
-                enable mips32r5
-                check_cflags "-mtune=p5600" && check_cflags "-msched-weight -mload-store-pairs -funroll-loops"
-            ;;
-            i6400)
-                enable mips64r6
-                check_cflags "-mtune=i6400 -mabi=64" && check_cflags "-msched-weight -mload-store-pairs -funroll-loops" && check_ldflags "-mabi=64"
-            ;;
-        esac
-    else
-        # We do not disable anything. Is up to the user to disable the unwanted features.
-        warn 'generic cpu selected'
-    fi
+    case $cpu in
+        24kc)
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable mipsfpu
+            disable mipsdsp
+            disable mipsdspr2
+            disable msa
+        ;;
+        24kf*)
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable mipsdsp
+            disable mipsdspr2
+            disable msa
+        ;;
+        24kec|34kc|1004kc)
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable mipsfpu
+            disable mipsdspr2
+            disable msa
+        ;;
+        24kef*|34kf*|1004kf*)
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable mipsdspr2
+            disable msa
+        ;;
+        74kc)
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable mipsfpu
+            disable msa
+        ;;
+        74kf)
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable msa
+        ;;
+        p5600)
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable mipsdsp
+            disable mipsdspr2
+            check_cflags "-mtune=p5600" &&
+            check_cflags "-mfp64 -msched-weight -mload-store-pairs -funroll-loops" &&
+            add_asflags "-mfp64"
+        ;;
+        i6400)
+            disable mips32r2
+            disable mips32r6
+            disable mips64r2
+            disable mipsdsp
+            disable mipsdspr2
+            check_cflags "-mtune=i6400 -mabi=64" &&
+            check_cflags "-mfp64 -msched-weight -mload-store-pairs -funroll-loops" &&
+            check_ldflags "-mabi=64" &&
+            add_asflags "-mfp64"
+        ;;
+        loongson*)
+            disable mips32r2
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable mipsfpu
+            disable mipsdsp
+            disable mipsdspr2
+            disable msa
+            enable local_aligned_8 local_aligned_16 local_aligned_32
+            enable simd_align_16
+            enable fast_64bit
+            enable fast_clz
+            enable fast_cmov
+            enable fast_unaligned
+            disable aligned_stack
+            case $cpu in
+                loongson3*)
+                    cpuflags="-march=loongson3a -mhard-float -fno-expensive-optimizations"
+                ;;
+                loongson2e)
+                    cpuflags="-march=loongson2e -mhard-float -fno-expensive-optimizations"
+                ;;
+                loongson2f)
+                    cpuflags="-march=loongson2f -mhard-float -fno-expensive-optimizations"
+                ;;
+            esac
+        ;;
+        generic)
+            disable mips64r6
+            disable msa
+        ;;
+        *)
+            # Unknown CPU. Disable everything.
+            warn "unknown CPU. Disabling all MIPS optimizations."
+            disable mipsfpu
+            disable mips32r2
+            disable mips32r6
+            disable mips64r2
+            disable mips64r6
+            disable mipsdsp
+            disable mipsdspr2
+            disable msa
+        ;;
+    esac

 elif enabled ppc; then

@@ -5066,22 +5073,27 @@ elif enabled mips; then
    enabled mmi && check_inline_asm mmi '"punpcklhw $f0, $f0, $f0"'

    # Enable minimum ISA based on selected options
-    if enabled mips64; then
-        enabled mips64r6 && check_inline_asm_flags mips64r6 '"dlsa $0, $0, $0, 1"' '-mips64r6'
-        enabled mips64r2 && check_inline_asm_flags mips64r2 '"dext $0, $0, 0, 1"' '-mips64r2'
-        disabled mips64r6 && disabled mips64r2 && check_inline_asm_flags mips64r1 '"daddi $0, $0, 0"' '-mips64'
-    else
-        enabled mips32r6 && check_inline_asm_flags mips32r6 '"aui $0, $0, 0"' '-mips32r6'
-        enabled mips32r5 && check_inline_asm_flags mips32r5 '"eretnc"' '-mips32r5'
-        enabled mips32r2 && check_inline_asm_flags mips32r2 '"ext $0, $0, 0, 1"' '-mips32r2'
-        disabled mips32r6 && disabled mips32r5 && disabled mips32r2 && check_inline_asm_flags mips32r1 '"addi $0, $0, 0"' '-mips32'
+    if enabled mips64 && (enabled mipsdsp || enabled mipsdspr2); then
+        add_cflags "-mips64r2"
+        add_asflags "-mips64r2"
+    elif enabled mips64 && enabled mipsfpu && disabled loongson2 && disabled loongson3; then
+        add_cflags "-mips64"
+        add_asflags "-mips64"
+    elif enabled mipsdsp || enabled mipsdspr2; then
+        add_cflags "-mips32r2 -mfp32"
+        add_asflags "-mips32r2 -mfp32"
    fi

-    enabled mipsfpu && check_inline_asm_flags mipsfpu '"cvt.d.l $f0, $f2"' '-mhard-float'
-    enabled mipsfpu && (enabled mips32r5 || enabled mips32r6 || enabled mips64r6) && check_inline_asm_flags mipsfpu '"cvt.d.l $f0, $f1"' '-mfp64'
-    enabled mipsfpu && enabled msa && check_inline_asm_flags msa '"addvi.b $w0, $w1, 1"' '-mmsa' && check_header msa.h || disable msa
-    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'
+    enabled mipsdsp && add_cflags "-mdsp" && add_asflags "-mdsp" &&
+     check_inline_asm mipsdsp '"addu.qb $t0, $t1, $t2"'
+    enabled mipsdspr2 && add_cflags "-mdspr2" && add_asflags "-mdspr2" &&
+     check_inline_asm mipsdspr2 '"absq_s.qb $t0, $t1"'
+    enabled mipsfpu   && add_cflags "-mhard-float" && add_asflags "-mhard-float" &&
+     check_inline_asm mipsfpu   '"madd.d $f0, $f2, $f4, $f6"'
+    enabled msa       && check_cflags "-mmsa" && check_ldflags "-mmsa" &&
+     check_inline_asm msa       '"addvi.b $w0, $w1, 1"'
+
+    enabled msa && add_asflags "-mmsa"

 elif enabled parisc; then

@@ -5647,7 +5659,7 @@ disabled securetransport || { check_func SecIdentityCreate "-Wl,-framework,CoreF
    enable 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; }
+                       enable schannel && add_extralibs -lSecur32; }

 makeinfo --version > /dev/null 2>&1 && enable makeinfo  || disable makeinfo
 enabled makeinfo \
--- a/doc/Doxyfile
+++ b/doc/Doxyfile
@@ -31,7 +31,7 @@ PROJECT_NAME           = FFmpeg
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.

-PROJECT_NUMBER         = 3.0.2
+PROJECT_NUMBER         =

 # With the PROJECT_LOGO tag one can specify a logo or icon that is included
 # in the documentation. The maximum height of the logo should not exceed 55
--- a/doc/demuxers.texi
+++ b/doc/demuxers.texi
@@ -104,7 +104,7 @@ All subsequent file-related directives apply to that file.

@item @code{ffconcat version 1.0}
 Identify the script type and version. It also sets the @option{safe} option
-to 1 if it was -1.
+to 1 if it was to its default -1.

 To make FFmpeg recognize the format automatically, this directive must
 appears exactly as is (no extra space or byte-order-mark) on the very first
@@ -192,9 +192,7 @@ component.

 If set to 0, any file name is accepted.

-The default is 1.
-
-1 is equivalent to 1 if the format was automatically
+The default is -1, it is equivalent to 1 if the format was automatically
 probed and 0 otherwise.

@item auto_convert
--- a/doc/utils.texi
+++ b/doc/utils.texi
@@ -869,7 +869,7 @@ Return 1 if @var{x} is lesser than or equal to @var{y}, 0 otherwise.
 Return the maximum between @var{x} and @var{y}.

@item min(x, y)
-Return the minimum between @var{x} and @var{y}.
+Return the maximum between @var{x} and @var{y}.

@item mod(x, y)
 Compute the remainder of division of @var{x} by @var{y}.
--- a/ffserver.c
+++ b/ffserver.c
@@ -373,8 +373,8 @@ static void ffm_set_write_index(AVFormatContext *s, int64_t pos,
                                int64_t file_size)
 {
    av_opt_set_int(s, "server_attached", 1, AV_OPT_SEARCH_CHILDREN);
-    av_opt_set_int(s, "ffm_write_index", pos, AV_OPT_SEARCH_CHILDREN);
-    av_opt_set_int(s, "ffm_file_size", file_size, AV_OPT_SEARCH_CHILDREN);
+    av_opt_set_int(s, "write_index", pos, AV_OPT_SEARCH_CHILDREN);
+    av_opt_set_int(s, "file_size", file_size, AV_OPT_SEARCH_CHILDREN);
 }

 static char *ctime1(char *buf2, size_t buf_size)
--- a/libavcodec/aacenc_utils.h
+++ b/libavcodec/aacenc_utils.h
@@ -28,7 +28,6 @@
 #ifndef AVCODEC_AACENC_UTILS_H
 #define AVCODEC_AACENC_UTILS_H

-#include "libavutil/internal.h"
 #include "aac.h"
 #include "aacenctab.h"
 #include "aactab.h"
@@ -67,13 +66,13 @@ static inline void quantize_bands(int *out, const float *in, const float *scaled
                                  const float rounding)
 {
    int i;
+    double qc;
    for (i = 0; i < size; i++) {
-        float qc = scaled[i] * Q34;
-        int tmp = (int)FFMIN(qc + rounding, (float)maxval);
+        qc = scaled[i] * Q34;
+        out[i] = (int)FFMIN(qc + rounding, (double)maxval);
        if (is_signed && in[i] < 0.0f) {
-            tmp = -tmp;
+            out[i] = -out[i];
        }
-        out[i] = tmp;
    }
 }

@@ -91,7 +90,8 @@ static inline float find_max_val(int group_len, int swb_size, const float *scale

 static inline int find_min_book(float maxval, int sf)
 {
-    float Q34 = ff_aac_pow34sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512];
+    float Q = ff_aac_pow2sf_tab[POW_SF2_ZERO - sf + SCALE_ONE_POS - SCALE_DIV_512];
+    float Q34 = sqrtf(Q * sqrtf(Q));
    int qmaxval, cb;
    qmaxval = maxval * Q34 + C_QUANT;
    if (qmaxval >= (FF_ARRAY_ELEMS(aac_maxval_cb)))
@@ -123,10 +123,7 @@ static inline float find_form_factor(int group_len, int swb_size, float thresh,
            if (s >= ethresh) {
                nzl += 1.0f;
            } else {
-                if (nzslope == 2.f)
-                    nzl += (s / ethresh) * (s / ethresh);
-                else
-                    nzl += ff_fast_powf(s / ethresh, nzslope);
+                nzl += powf(s / ethresh, nzslope);
            }
        }
        if (e2 > thresh) {
--- a/libavcodec/ac3dec.c
+++ b/libavcodec/ac3dec.c
@@ -895,13 +895,11 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
                                  ff_eac3_default_spx_band_struct,
                                  &s->num_spx_bands,
                                  s->spx_band_sizes);
-        }
-    }
-    if (!s->eac3 || !s->spx_in_use) {
-        s->spx_in_use = 0;
-        for (ch = 1; ch <= fbw_channels; ch++) {
-            s->channel_uses_spx[ch] = 0;
-            s->first_spx_coords[ch] = 1;
+        } else {
+            for (ch = 1; ch <= fbw_channels; ch++) {
+                s->channel_uses_spx[ch] = 0;
+                s->first_spx_coords[ch] = 1;
+            }
        }
    }

--- a/libavcodec/apedec.c
+++ b/libavcodec/apedec.c
@@ -1372,7 +1372,7 @@ static void ape_unpack_stereo(APEContext *ctx, int count)
    int32_t *decoded0 = ctx->decoded[0];
    int32_t *decoded1 = ctx->decoded[1];

-    if ((ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) == APE_FRAMECODE_STEREO_SILENCE) {
+    if (ctx->frameflags & APE_FRAMECODE_STEREO_SILENCE) {
        /* We are pure silence, so we're done. */
        av_log(ctx->avctx, AV_LOG_DEBUG, "pure silence stereo\n");
        return;
--- a/libavcodec/avpacket.c
+++ b/libavcodec/avpacket.c
@@ -401,12 +401,10 @@ int av_packet_split_side_data(AVPacket *pkt){
        p = pkt->data + pkt->size - 8 - 5;
        for (i=1; ; i++){
            size = AV_RB32(p);
-            if (size>INT_MAX - 5 || p - pkt->data < size)
+            if (size>INT_MAX || p - pkt->data < size)
                return 0;
            if (p[4]&128)
                break;
-            if (p - pkt->data < size + 5)
-                return 0;
            p-= size+5;
        }

@@ -417,7 +415,7 @@ int av_packet_split_side_data(AVPacket *pkt){
        p= pkt->data + pkt->size - 8 - 5;
        for (i=0; ; i++){
            size= AV_RB32(p);
-            av_assert0(size<=INT_MAX - 5 && p - pkt->data >= size);
+            av_assert0(size<=INT_MAX && p - pkt->data >= size);
            pkt->side_data[i].data = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
            pkt->side_data[i].size = size;
            pkt->side_data[i].type = p[4]&127;
--- a/libavcodec/bmp_parser.c
+++ b/libavcodec/bmp_parser.c
@@ -63,7 +63,7 @@ restart:
                    continue;
                }
                bpc->pc.frame_start_found++;
-                bpc->remaining_size = bpc->fsize + FFMAX(i - 17, 0);
+                bpc->remaining_size = bpc->fsize + i - 17;

                if (bpc->pc.index + i > 17) {
                    next = i - 17;
--- a/libavcodec/cfhd.c
+++ b/libavcodec/cfhd.c
@@ -756,6 +756,6 @@ AVCodec ff_cfhd_decoder = {
    .init           = cfhd_decode_init,
    .close          = cfhd_close_decoder,
    .decode         = cfhd_decode,
-    .capabilities   = AV_CODEC_CAP_DR1,
+    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 };
--- a/libavcodec/dca_core.c
+++ b/libavcodec/dca_core.c
@@ -1760,7 +1760,6 @@ static int parse_x96_frame_exss(DCACoreDecoder *s)
        return ret;

    // Channel set data
-    s->x96_nchannels = 0;
    for (i = 0, x96_base_ch = 0; i < x96_nchsets; i++) {
        header_pos = get_bits_count(&s->gb);

--- a/libavcodec/diracdec.c
+++ b/libavcodec/diracdec.c
@@ -173,7 +173,7 @@ typedef struct DiracContext {

    struct {
        unsigned prefix_bytes;
-        uint64_t size_scaler;
+        unsigned size_scaler;
    } highquality;

    struct {
@@ -826,15 +826,9 @@ static int decode_hq_slice(AVCodecContext *avctx, void *arg)

    /* Luma + 2 Chroma planes */
    for (i = 0; i < 3; i++) {
-        int64_t length = s->highquality.size_scaler * get_bits(gb, 8);
-        int64_t bits_left = 8 * length;
-        int64_t bits_end = get_bits_count(gb) + bits_left;
-
-        if (bits_end >= INT_MAX) {
-            av_log(s->avctx, AV_LOG_ERROR, "end too far away\n");
-            return AVERROR_INVALIDDATA;
-        }
-
+        int length = s->highquality.size_scaler * get_bits(gb, 8);
+        int bits_left = 8 * length;
+        int bits_end = get_bits_count(gb) + bits_left;
        for (level = 0; level < s->wavelet_depth; level++) {
            for (orientation = !!level; orientation < 4; orientation++) {
                decode_subband(s, gb, quants[level][orientation], slice->slice_x, slice->slice_y, bits_end,
@@ -854,8 +848,7 @@ static int decode_hq_slice(AVCodecContext *avctx, void *arg)
 static int decode_lowdelay(DiracContext *s)
 {
    AVCodecContext *avctx = s->avctx;
-    int slice_x, slice_y, bufsize;
-    int64_t bytes = 0;
+    int slice_x, slice_y, bytes = 0, bufsize;
    const uint8_t *buf;
    DiracSlice *slices;
    int slice_num = 0;
@@ -879,11 +872,6 @@ static int decode_lowdelay(DiracContext *s)
                    if (bytes <= bufsize/8)
                        bytes += buf[bytes] * s->highquality.size_scaler + 1;
                }
-                if (bytes >= INT_MAX) {
-                    av_log(s->avctx, AV_LOG_ERROR, "too many bytes\n");
-                    av_free(slices);
-                    return AVERROR_INVALIDDATA;
-                }

                slices[slice_num].bytes   = bytes;
                slices[slice_num].slice_x = slice_x;
@@ -1163,10 +1151,6 @@ static int dirac_unpack_idwt_params(DiracContext *s)
        } else if (s->hq_picture) {
            s->highquality.prefix_bytes = svq3_get_ue_golomb(gb);
            s->highquality.size_scaler  = svq3_get_ue_golomb(gb);
-            if (s->highquality.prefix_bytes >= INT_MAX / 8) {
-                av_log(s->avctx,AV_LOG_ERROR,"too many prefix bytes\n");
-                return AVERROR_INVALIDDATA;
-            }
        }

        /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
--- a/libavcodec/h264.c
+++ b/libavcodec/h264.c
@@ -1678,47 +1678,6 @@ again:

    ret = 0;
 end:
-
-#if CONFIG_ERROR_RESILIENCE
-    sl = h->slice_ctx;
-    /*
-     * FIXME: Error handling code does not seem to support interlaced
-     * when slices span multiple rows
-     * The ff_er_add_slice calls don't work right for bottom
-     * fields; they cause massive erroneous error concealing
-     * Error marking covers both fields (top and bottom).
-     * This causes a mismatched s->error_count
-     * and a bad error table. Further, the error count goes to
-     * INT_MAX when called for bottom field, because mb_y is
-     * past end by one (callers fault) and resync_mb_y != 0
-     * causes problems for the first MB line, too.
-     */
-    if (!FIELD_PICTURE(h) && h->current_slice && !h->sps.new && h->enable_er) {
-        int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
-
-        ff_h264_set_erpic(&sl->er.cur_pic, h->cur_pic_ptr);
-
-        if (use_last_pic) {
-            ff_h264_set_erpic(&sl->er.last_pic, &h->last_pic_for_ec);
-            sl->ref_list[0][0].parent = &h->last_pic_for_ec;
-            memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
-            memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
-            sl->ref_list[0][0].reference = h->last_pic_for_ec.reference;
-        } else if (sl->ref_count[0]) {
-            ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);
-        } else
-            ff_h264_set_erpic(&sl->er.last_pic, NULL);
-
-        if (sl->ref_count[1])
-            ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);
-
-        sl->er.ref_count = sl->ref_count[0];
-
-        ff_er_frame_end(&sl->er);
-        if (use_last_pic)
-            memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
-    }
-#endif /* CONFIG_ERROR_RESILIENCE */
    /* clean up */
    if (h->cur_pic_ptr && !h->droppable) {
        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
@@ -1781,7 +1740,7 @@ static int is_extra(const uint8_t *buf, int buf_size)
    const uint8_t *p= buf+6;
    while(cnt--){
        int nalsize= AV_RB16(p) + 2;
-        if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)
+        if(nalsize > buf_size - (p-buf) || p[2]!=0x67)
            return 0;
        p += nalsize;
    }
@@ -1790,7 +1749,7 @@ static int is_extra(const uint8_t *buf, int buf_size)
        return 0;
    while(cnt--){
        int nalsize= AV_RB16(p) + 2;
-        if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
+        if(nalsize > buf_size - (p-buf) || p[2]!=0x68)
            return 0;
        p += nalsize;
    }
--- a/libavcodec/h264_picture.c
+++ b/libavcodec/h264_picture.c
@@ -186,6 +186,47 @@ int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
        ff_vdpau_h264_picture_complete(h);
 #endif

+#if CONFIG_ERROR_RESILIENCE
+    av_assert0(sl == h->slice_ctx);
+    /*
+     * FIXME: Error handling code does not seem to support interlaced
+     * when slices span multiple rows
+     * The ff_er_add_slice calls don't work right for bottom
+     * fields; they cause massive erroneous error concealing
+     * Error marking covers both fields (top and bottom).
+     * This causes a mismatched s->error_count
+     * and a bad error table. Further, the error count goes to
+     * INT_MAX when called for bottom field, because mb_y is
+     * past end by one (callers fault) and resync_mb_y != 0
+     * causes problems for the first MB line, too.
+     */
+    if (!FIELD_PICTURE(h) && h->current_slice && !h->sps.new && h->enable_er) {
+        int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
+
+        ff_h264_set_erpic(&sl->er.cur_pic, h->cur_pic_ptr);
+
+        if (use_last_pic) {
+            ff_h264_set_erpic(&sl->er.last_pic, &h->last_pic_for_ec);
+            sl->ref_list[0][0].parent = &h->last_pic_for_ec;
+            memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
+            memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
+            sl->ref_list[0][0].reference = h->last_pic_for_ec.reference;
+        } else if (sl->ref_count[0]) {
+            ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);
+        } else
+            ff_h264_set_erpic(&sl->er.last_pic, NULL);
+
+        if (sl->ref_count[1])
+            ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);
+
+        sl->er.ref_count = sl->ref_count[0];
+
+        ff_er_frame_end(&sl->er);
+        if (use_last_pic)
+            memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
+    }
+#endif /* CONFIG_ERROR_RESILIENCE */
+
    if (!in_setup && !h->droppable)
        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
                                  h->picture_structure == PICT_BOTTOM_FIELD);
--- a/libavcodec/h264_slice.c
+++ b/libavcodec/h264_slice.c
@@ -1282,13 +1282,9 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl)

    if (first_slice) {
        h->pps = *h->pps_buffers[pps_id];
-    } else {
-        if (h->pps.sps_id != pps->sps_id ||
-            h->pps.transform_8x8_mode != pps->transform_8x8_mode ||
-            (h->setup_finished && h->dequant_coeff_pps != pps_id)) {
-            av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
-            return AVERROR_INVALIDDATA;
-        }
+    } else if (h->setup_finished && h->dequant_coeff_pps != pps_id) {
+        av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
+        return AVERROR_INVALIDDATA;
    }

    if (pps->sps_id != h->sps.sps_id ||
--- a/libavcodec/hevc_parse.c
+++ b/libavcodec/hevc_parse.c
@@ -232,14 +232,8 @@ int ff_hevc_split_packet(HEVCContext *s, HEVCPacket *pkt, const uint8_t *buf, in
                ++buf;
                --length;
                if (length < 4) {
-                    if (pkt->nb_nals > 0) {
-                        // No more start codes: we discarded some irrelevant
-                        // bytes at the end of the packet.
-                        return 0;
-                    } else {
-                        av_log(avctx, AV_LOG_ERROR, "No start code is found.\n");
-                        return AVERROR_INVALIDDATA;
-                    }
+                    av_log(avctx, AV_LOG_ERROR, "No start code is found.\n");
+                    return AVERROR_INVALIDDATA;
                }
            }

--- a/libavcodec/indeo2.c
+++ b/libavcodec/indeo2.c
@@ -146,7 +146,6 @@ static int ir2_decode_frame(AVCodecContext *avctx,
    AVFrame *picture     = data;
    AVFrame * const p    = s->picture;
    int start, ret;
-    int ltab, ctab;

    if ((ret = ff_reget_buffer(avctx, p)) < 0)
        return ret;
@@ -169,36 +168,34 @@ static int ir2_decode_frame(AVCodecContext *avctx,
    if ((ret = init_get_bits8(&s->gb, buf + start, buf_size - start)) < 0)
        return ret;

-    ltab = buf[0x22] & 3;
-    ctab = buf[0x22] >> 2;
    if (s->decode_delta) { /* intraframe */
        if ((ret = ir2_decode_plane(s, avctx->width, avctx->height,
                                    p->data[0], p->linesize[0],
-                                    ir2_delta_table[ltab])) < 0)
+                                    ir2_luma_table)) < 0)
            return ret;

        /* swapped U and V */
        if ((ret = ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
                                    p->data[2], p->linesize[2],
-                                    ir2_delta_table[ctab])) < 0)
+                                    ir2_luma_table)) < 0)
            return ret;
        if ((ret = ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
                                    p->data[1], p->linesize[1],
-                                    ir2_delta_table[ctab])) < 0)
+                                    ir2_luma_table)) < 0)
            return ret;
    } else { /* interframe */
        if ((ret = ir2_decode_plane_inter(s, avctx->width, avctx->height,
                                          p->data[0], p->linesize[0],
-                                          ir2_delta_table[ltab])) < 0)
+                                          ir2_luma_table)) < 0)
            return ret;
        /* swapped U and V */
        if ((ret = ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
                                          p->data[2], p->linesize[2],
-                                          ir2_delta_table[ctab])) < 0)
+                                          ir2_luma_table)) < 0)
            return ret;
        if ((ret = ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
                                          p->data[1], p->linesize[1],
-                                          ir2_delta_table[ctab])) < 0)
+                                          ir2_luma_table)) < 0)
            return ret;
    }

--- a/libavcodec/indeo2data.h
+++ b/libavcodec/indeo2data.h
@@ -27,211 +27,115 @@
 #define IR2_CODES 143
 static const uint16_t ir2_codes[IR2_CODES][2] = {
 #ifdef BITSTREAM_READER_LE
-    { 0x0000,  3 }, { 0x0004,  3 }, { 0x0006,  3 }, { 0x0001,  5 },
-    { 0x0009,  5 }, { 0x0019,  5 }, { 0x000D,  5 }, { 0x001D,  5 },
-    { 0x0023,  6 }, { 0x0013,  6 }, { 0x0033,  6 }, { 0x000B,  6 },
-    { 0x002B,  6 }, { 0x001B,  6 }, { 0x0007,  8 }, { 0x0087,  8 },
-    { 0x0027,  8 }, { 0x00A7,  8 }, { 0x0067,  8 }, { 0x00E7,  8 },
-    { 0x0097,  8 }, { 0x0057,  8 }, { 0x0037,  8 }, { 0x00B7,  8 },
-    { 0x00F7,  8 }, { 0x000F,  9 }, { 0x008F,  9 }, { 0x018F,  9 },
-    { 0x014F,  9 }, { 0x00CF,  9 }, { 0x002F,  9 }, { 0x012F,  9 },
-    { 0x01AF,  9 }, { 0x006F,  9 }, { 0x00EF,  9 }, { 0x01EF,  9 },
-    { 0x001F, 10 }, { 0x021F, 10 }, { 0x011F, 10 }, { 0x031F, 10 },
-    { 0x009F, 10 }, { 0x029F, 10 }, { 0x019F, 10 }, { 0x039F, 10 },
-    { 0x005F, 10 }, { 0x025F, 10 }, { 0x015F, 10 }, { 0x035F, 10 },
-    { 0x00DF, 10 }, { 0x02DF, 10 }, { 0x01DF, 10 }, { 0x03DF, 10 },
-    { 0x003F, 13 }, { 0x103F, 13 }, { 0x083F, 13 }, { 0x183F, 13 },
-    { 0x043F, 13 }, { 0x143F, 13 }, { 0x0C3F, 13 }, { 0x1C3F, 13 },
-    { 0x023F, 13 }, { 0x123F, 13 }, { 0x0A3F, 13 }, { 0x1A3F, 13 },
-    { 0x063F, 13 }, { 0x163F, 13 }, { 0x0E3F, 13 }, { 0x1E3F, 13 },
-    { 0x013F, 13 }, { 0x113F, 13 }, { 0x093F, 13 }, { 0x193F, 13 },
-    { 0x053F, 13 }, { 0x153F, 13 }, { 0x0D3F, 13 }, { 0x1D3F, 13 },
-    { 0x033F, 13 }, { 0x133F, 13 }, { 0x0B3F, 13 }, { 0x1B3F, 13 },
-    { 0x073F, 13 }, { 0x173F, 13 }, { 0x0F3F, 13 }, { 0x1F3F, 13 },
-    { 0x00BF, 13 }, { 0x10BF, 13 }, { 0x08BF, 13 }, { 0x18BF, 13 },
-    { 0x04BF, 13 }, { 0x14BF, 13 }, { 0x0CBF, 13 }, { 0x1CBF, 13 },
-    { 0x02BF, 13 }, { 0x12BF, 13 }, { 0x0ABF, 13 }, { 0x1ABF, 13 },
-    { 0x06BF, 13 }, { 0x16BF, 13 }, { 0x0EBF, 13 }, { 0x1EBF, 13 },
-    { 0x01BF, 13 }, { 0x11BF, 13 }, { 0x09BF, 13 }, { 0x19BF, 13 },
-    { 0x05BF, 13 }, { 0x15BF, 13 }, { 0x0DBF, 13 }, { 0x1DBF, 13 },
-    { 0x03BF, 13 }, { 0x13BF, 13 }, { 0x0BBF, 13 }, { 0x1BBF, 13 },
-    { 0x07BF, 13 }, { 0x17BF, 13 }, { 0x0FBF, 13 }, { 0x1FBF, 13 },
-    { 0x007F, 14 }, { 0x207F, 14 }, { 0x107F, 14 }, { 0x307F, 14 },
-    { 0x087F, 14 }, { 0x287F, 14 }, { 0x187F, 14 }, { 0x387F, 14 },
-    { 0x047F, 14 }, { 0x247F, 14 }, { 0x147F, 14 }, { 0x0002,  3 },
-    { 0x0011,  5 }, { 0x0005,  5 }, { 0x0015,  5 }, { 0x0003,  6 },
-    { 0x003B,  6 }, { 0x0047,  8 }, { 0x00C7,  8 }, { 0x0017,  8 },
-    { 0x00D7,  8 }, { 0x0077,  8 }, { 0x010F,  9 }, { 0x004F,  9 },
-    { 0x01CF,  9 }, { 0x00AF,  9 }, { 0x016F,  9 },
+{0x0000,  3}, {0x0004,  3}, {0x0006,  3}, {0x0001,  5},
+{0x0009,  5}, {0x0019,  5}, {0x000D,  5}, {0x001D,  5},
+{0x0023,  6}, {0x0013,  6}, {0x0033,  6}, {0x000B,  6},
+{0x002B,  6}, {0x001B,  6}, {0x0007,  8}, {0x0087,  8},
+{0x0027,  8}, {0x00A7,  8}, {0x0067,  8}, {0x00E7,  8},
+{0x0097,  8}, {0x0057,  8}, {0x0037,  8}, {0x00B7,  8},
+{0x00F7,  8}, {0x000F,  9}, {0x008F,  9}, {0x018F,  9},
+{0x014F,  9}, {0x00CF,  9}, {0x002F,  9}, {0x012F,  9},
+{0x01AF,  9}, {0x006F,  9}, {0x00EF,  9}, {0x01EF,  9},
+{0x001F, 10}, {0x021F, 10}, {0x011F, 10}, {0x031F, 10},
+{0x009F, 10}, {0x029F, 10}, {0x019F, 10}, {0x039F, 10},
+{0x005F, 10}, {0x025F, 10}, {0x015F, 10}, {0x035F, 10},
+{0x00DF, 10}, {0x02DF, 10}, {0x01DF, 10}, {0x03DF, 10},
+{0x003F, 13}, {0x103F, 13}, {0x083F, 13}, {0x183F, 13},
+{0x043F, 13}, {0x143F, 13}, {0x0C3F, 13}, {0x1C3F, 13},
+{0x023F, 13}, {0x123F, 13}, {0x0A3F, 13}, {0x1A3F, 13},
+{0x063F, 13}, {0x163F, 13}, {0x0E3F, 13}, {0x1E3F, 13},
+{0x013F, 13}, {0x113F, 13}, {0x093F, 13}, {0x193F, 13},
+{0x053F, 13}, {0x153F, 13}, {0x0D3F, 13}, {0x1D3F, 13},
+{0x033F, 13}, {0x133F, 13}, {0x0B3F, 13}, {0x1B3F, 13},
+{0x073F, 13}, {0x173F, 13}, {0x0F3F, 13}, {0x1F3F, 13},
+{0x00BF, 13}, {0x10BF, 13}, {0x08BF, 13}, {0x18BF, 13},
+{0x04BF, 13}, {0x14BF, 13}, {0x0CBF, 13}, {0x1CBF, 13},
+{0x02BF, 13}, {0x12BF, 13}, {0x0ABF, 13}, {0x1ABF, 13},
+{0x06BF, 13}, {0x16BF, 13}, {0x0EBF, 13}, {0x1EBF, 13},
+{0x01BF, 13}, {0x11BF, 13}, {0x09BF, 13}, {0x19BF, 13},
+{0x05BF, 13}, {0x15BF, 13}, {0x0DBF, 13}, {0x1DBF, 13},
+{0x03BF, 13}, {0x13BF, 13}, {0x0BBF, 13}, {0x1BBF, 13},
+{0x07BF, 13}, {0x17BF, 13}, {0x0FBF, 13}, {0x1FBF, 13},
+{0x007F, 14}, {0x207F, 14}, {0x107F, 14}, {0x307F, 14},
+{0x087F, 14}, {0x287F, 14}, {0x187F, 14}, {0x387F, 14},
+{0x047F, 14}, {0x247F, 14}, {0x147F, 14}, {0x0002,  3},
+{0x0011,  5}, {0x0005,  5}, {0x0015,  5}, {0x0003,  6},
+{0x003B,  6}, {0x0047,  8}, {0x00C7,  8}, {0x0017,  8},
+{0x00D7,  8}, {0x0077,  8}, {0x010F,  9}, {0x004F,  9},
+{0x01CF,  9}, {0x00AF,  9}, {0x016F,  9},
 #else
-    { 0x0000,  3 }, { 0x0001,  3 }, { 0x0003,  3 }, { 0x0010,  5 },
-    { 0x0012,  5 }, { 0x0013,  5 }, { 0x0016,  5 }, { 0x0017,  5 },
-    { 0x0031,  6 }, { 0x0032,  6 }, { 0x0033,  6 }, { 0x0034,  6 },
-    { 0x0035,  6 }, { 0x0036,  6 }, { 0x00E0,  8 }, { 0x00E1,  8 },
-    { 0x00E4,  8 }, { 0x00E5,  8 }, { 0x00E6,  8 }, { 0x00E7,  8 },
-    { 0x00E9,  8 }, { 0x00EA,  8 }, { 0x00EC,  8 }, { 0x00ED,  8 },
-    { 0x00EF,  8 }, { 0x01E0,  9 }, { 0x01E2,  9 }, { 0x01E3,  9 },
-    { 0x01E5,  9 }, { 0x01E6,  9 }, { 0x01E8,  9 }, { 0x01E9,  9 },
-    { 0x01EB,  9 }, { 0x01EC,  9 }, { 0x01EE,  9 }, { 0x01EF,  9 },
-    { 0x03E0, 10 }, { 0x03E1, 10 }, { 0x03E2, 10 }, { 0x03E3, 10 },
-    { 0x03E4, 10 }, { 0x03E5, 10 }, { 0x03E6, 10 }, { 0x03E7, 10 },
-    { 0x03E8, 10 }, { 0x03E9, 10 }, { 0x03EA, 10 }, { 0x03EB, 10 },
-    { 0x03EC, 10 }, { 0x03ED, 10 }, { 0x03EE, 10 }, { 0x03EF, 10 },
-    { 0x1F80, 13 }, { 0x1F81, 13 }, { 0x1F82, 13 }, { 0x1F83, 13 },
-    { 0x1F84, 13 }, { 0x1F85, 13 }, { 0x1F86, 13 }, { 0x1F87, 13 },
-    { 0x1F88, 13 }, { 0x1F89, 13 }, { 0x1F8A, 13 }, { 0x1F8B, 13 },
-    { 0x1F8C, 13 }, { 0x1F8D, 13 }, { 0x1F8E, 13 }, { 0x1F8F, 13 },
-    { 0x1F90, 13 }, { 0x1F91, 13 }, { 0x1F92, 13 }, { 0x1F93, 13 },
-    { 0x1F94, 13 }, { 0x1F95, 13 }, { 0x1F96, 13 }, { 0x1F97, 13 },
-    { 0x1F98, 13 }, { 0x1F99, 13 }, { 0x1F9A, 13 }, { 0x1F9B, 13 },
-    { 0x1F9C, 13 }, { 0x1F9D, 13 }, { 0x1F9E, 13 }, { 0x1F9F, 13 },
-    { 0x1FA0, 13 }, { 0x1FA1, 13 }, { 0x1FA2, 13 }, { 0x1FA3, 13 },
-    { 0x1FA4, 13 }, { 0x1FA5, 13 }, { 0x1FA6, 13 }, { 0x1FA7, 13 },
-    { 0x1FA8, 13 }, { 0x1FA9, 13 }, { 0x1FAA, 13 }, { 0x1FAB, 13 },
-    { 0x1FAC, 13 }, { 0x1FAD, 13 }, { 0x1FAE, 13 }, { 0x1FAF, 13 },
-    { 0x1FB0, 13 }, { 0x1FB1, 13 }, { 0x1FB2, 13 }, { 0x1FB3, 13 },
-    { 0x1FB4, 13 }, { 0x1FB5, 13 }, { 0x1FB6, 13 }, { 0x1FB7, 13 },
-    { 0x1FB8, 13 }, { 0x1FB9, 13 }, { 0x1FBA, 13 }, { 0x1FBB, 13 },
-    { 0x1FBC, 13 }, { 0x1FBD, 13 }, { 0x1FBE, 13 }, { 0x1FBF, 13 },
-    { 0x3F80, 14 }, { 0x3F81, 14 }, { 0x3F82, 14 }, { 0x3F83, 14 },
-    { 0x3F84, 14 }, { 0x3F85, 14 }, { 0x3F86, 14 }, { 0x3F87, 14 },
-    { 0x3F88, 14 }, { 0x3F89, 14 }, { 0x3F8A, 14 }, { 0x0002,  3 },
-    { 0x0011,  5 }, { 0x0014,  5 }, { 0x0015,  5 }, { 0x0030,  6 },
-    { 0x0037,  6 }, { 0x00E2,  8 }, { 0x00E3,  8 }, { 0x00E8,  8 },
-    { 0x00EB,  8 }, { 0x00EE,  8 }, { 0x01E1,  9 }, { 0x01E4,  9 },
-    { 0x01E7,  9 }, { 0x01EA,  9 }, { 0x01ED,  9 },
+    {0x0000,  3}, {0x0001,  3}, {0x0003,  3}, {0x0010,  5},
+    {0x0012,  5}, {0x0013,  5}, {0x0016,  5}, {0x0017,  5},
+    {0x0031,  6}, {0x0032,  6}, {0x0033,  6}, {0x0034,  6},
+    {0x0035,  6}, {0x0036,  6}, {0x00E0,  8}, {0x00E1,  8},
+    {0x00E4,  8}, {0x00E5,  8}, {0x00E6,  8}, {0x00E7,  8},
+    {0x00E9,  8}, {0x00EA,  8}, {0x00EC,  8}, {0x00ED,  8},
+    {0x00EF,  8}, {0x01E0,  9}, {0x01E2,  9}, {0x01E3,  9},
+    {0x01E5,  9}, {0x01E6,  9}, {0x01E8,  9}, {0x01E9,  9},
+    {0x01EB,  9}, {0x01EC,  9}, {0x01EE,  9}, {0x01EF,  9},
+    {0x03E0, 10}, {0x03E1, 10}, {0x03E2, 10}, {0x03E3, 10},
+    {0x03E4, 10}, {0x03E5, 10}, {0x03E6, 10}, {0x03E7, 10},
+    {0x03E8, 10}, {0x03E9, 10}, {0x03EA, 10}, {0x03EB, 10},
+    {0x03EC, 10}, {0x03ED, 10}, {0x03EE, 10}, {0x03EF, 10},
+    {0x1F80, 13}, {0x1F81, 13}, {0x1F82, 13}, {0x1F83, 13},
+    {0x1F84, 13}, {0x1F85, 13}, {0x1F86, 13}, {0x1F87, 13},
+    {0x1F88, 13}, {0x1F89, 13}, {0x1F8A, 13}, {0x1F8B, 13},
+    {0x1F8C, 13}, {0x1F8D, 13}, {0x1F8E, 13}, {0x1F8F, 13},
+    {0x1F90, 13}, {0x1F91, 13}, {0x1F92, 13}, {0x1F93, 13},
+    {0x1F94, 13}, {0x1F95, 13}, {0x1F96, 13}, {0x1F97, 13},
+    {0x1F98, 13}, {0x1F99, 13}, {0x1F9A, 13}, {0x1F9B, 13},
+    {0x1F9C, 13}, {0x1F9D, 13}, {0x1F9E, 13}, {0x1F9F, 13},
+    {0x1FA0, 13}, {0x1FA1, 13}, {0x1FA2, 13}, {0x1FA3, 13},
+    {0x1FA4, 13}, {0x1FA5, 13}, {0x1FA6, 13}, {0x1FA7, 13},
+    {0x1FA8, 13}, {0x1FA9, 13}, {0x1FAA, 13}, {0x1FAB, 13},
+    {0x1FAC, 13}, {0x1FAD, 13}, {0x1FAE, 13}, {0x1FAF, 13},
+    {0x1FB0, 13}, {0x1FB1, 13}, {0x1FB2, 13}, {0x1FB3, 13},
+    {0x1FB4, 13}, {0x1FB5, 13}, {0x1FB6, 13}, {0x1FB7, 13},
+    {0x1FB8, 13}, {0x1FB9, 13}, {0x1FBA, 13}, {0x1FBB, 13},
+    {0x1FBC, 13}, {0x1FBD, 13}, {0x1FBE, 13}, {0x1FBF, 13},
+    {0x3F80, 14}, {0x3F81, 14}, {0x3F82, 14}, {0x3F83, 14},
+    {0x3F84, 14}, {0x3F85, 14}, {0x3F86, 14}, {0x3F87, 14},
+    {0x3F88, 14}, {0x3F89, 14}, {0x3F8A, 14}, {0x0002,  3},
+    {0x0011,  5}, {0x0014,  5}, {0x0015,  5}, {0x0030,  6},
+    {0x0037,  6}, {0x00E2,  8}, {0x00E3,  8}, {0x00E8,  8},
+    {0x00EB,  8}, {0x00EE,  8}, {0x01E1,  9}, {0x01E4,  9},
+    {0x01E7,  9}, {0x01EA,  9}, {0x01ED,  9}
 #endif
 };

-static const uint8_t ir2_delta_table[4][256] = {
-    { 0x80, 0x80, 0x84, 0x84, 0x7C, 0x7C, 0x7F, 0x85,
-      0x81, 0x7B, 0x85, 0x7F, 0x7B, 0x81, 0x8C, 0x8C,
-      0x74, 0x74, 0x83, 0x8D, 0x7D, 0x73, 0x8D, 0x83,
-      0x73, 0x7D, 0x77, 0x89, 0x89, 0x77, 0x89, 0x77,
-      0x77, 0x89, 0x8C, 0x95, 0x74, 0x6B, 0x95, 0x8C,
-      0x6B, 0x74, 0x7C, 0x90, 0x84, 0x70, 0x90, 0x7C,
-      0x70, 0x84, 0x96, 0x96, 0x6A, 0x6A, 0x82, 0x98,
-      0x7E, 0x68, 0x98, 0x82, 0x68, 0x7E, 0x97, 0xA2,
-      0x69, 0x5E, 0xA2, 0x97, 0x5E, 0x69, 0xA2, 0xA2,
-      0x5E, 0x5E, 0x8B, 0xA3, 0x75, 0x5D, 0xA3, 0x8B,
-      0x5D, 0x75, 0x71, 0x95, 0x8F, 0x6B, 0x95, 0x71,
-      0x6B, 0x8F, 0x78, 0x9D, 0x88, 0x63, 0x9D, 0x78,
-      0x63, 0x88, 0x7F, 0xA7, 0x81, 0x59, 0xA7, 0x7F,
-      0x59, 0x81, 0xA4, 0xB1, 0x5C, 0x4F, 0xB1, 0xA4,
-      0x4F, 0x5C, 0x96, 0xB1, 0x6A, 0x4F, 0xB1, 0x96,
-      0x4F, 0x6A, 0xB2, 0xB2, 0x4E, 0x4E, 0x65, 0x9B,
-      0x9B, 0x65, 0x9B, 0x65, 0x65, 0x9B, 0x89, 0xB4,
-      0x77, 0x4C, 0xB4, 0x89, 0x4C, 0x77, 0x6A, 0xA3,
-      0x96, 0x5D, 0xA3, 0x6A, 0x5D, 0x96, 0x73, 0xAC,
-      0x8D, 0x54, 0xAC, 0x73, 0x54, 0x8D, 0xB4, 0xC3,
-      0x4C, 0x3D, 0xC3, 0xB4, 0x3D, 0x4C, 0xA4, 0xC3,
-      0x5C, 0x3D, 0xC3, 0xA4, 0x3D, 0x5C, 0xC4, 0xC4,
-      0x3C, 0x3C, 0x96, 0xC6, 0x6A, 0x3A, 0xC6, 0x96,
-      0x3A, 0x6A, 0x7C, 0xBA, 0x84, 0x46, 0xBA, 0x7C,
-      0x46, 0x84, 0x5B, 0xAB, 0xA5, 0x55, 0xAB, 0x5B,
-      0x55, 0xA5, 0x63, 0xB4, 0x9D, 0x4C, 0xB4, 0x63,
-      0x4C, 0x9D, 0x86, 0xCA, 0x7A, 0x36, 0xCA, 0x86,
-      0x36, 0x7A, 0xB6, 0xD7, 0x4A, 0x29, 0xD7, 0xB6,
-      0x29, 0x4A, 0xC8, 0xD7, 0x38, 0x29, 0xD7, 0xC8,
-      0x29, 0x38, 0xA4, 0xD8, 0x5C, 0x28, 0xD8, 0xA4,
-      0x28, 0x5C, 0x6C, 0xC1, 0x94, 0x3F, 0xC1, 0x6C,
-      0x3F, 0x94, 0xD9, 0xD9, 0x27, 0x27, 0x80, 0x80, },
-    { 0x80, 0x80, 0x85, 0x85, 0x7B, 0x7B, 0x7E, 0x87,
-      0x82, 0x79, 0x87, 0x7E, 0x79, 0x82, 0x8F, 0x8F,
-      0x71, 0x71, 0x84, 0x8F, 0x7C, 0x71, 0x8F, 0x84,
-      0x71, 0x7C, 0x75, 0x8B, 0x8B, 0x75, 0x8B, 0x75,
-      0x75, 0x8B, 0x8E, 0x9A, 0x72, 0x66, 0x9A, 0x8E,
-      0x66, 0x72, 0x7B, 0x93, 0x85, 0x6D, 0x93, 0x7B,
-      0x6D, 0x85, 0x9B, 0x9B, 0x65, 0x65, 0x82, 0x9D,
-      0x7E, 0x63, 0x9D, 0x82, 0x63, 0x7E, 0x9B, 0xA8,
-      0x65, 0x58, 0xA8, 0x9B, 0x58, 0x65, 0xA9, 0xA9,
-      0x57, 0x57, 0x8D, 0xAA, 0x73, 0x56, 0xAA, 0x8D,
-      0x56, 0x73, 0x6E, 0x99, 0x92, 0x67, 0x99, 0x6E,
-      0x67, 0x92, 0x76, 0xA2, 0x8A, 0x5E, 0xA2, 0x76,
-      0x5E, 0x8A, 0x7F, 0xAF, 0x81, 0x51, 0xAF, 0x7F,
-      0x51, 0x81, 0xAB, 0xBA, 0x55, 0x46, 0xBA, 0xAB,
-      0x46, 0x55, 0x9A, 0xBB, 0x66, 0x45, 0xBB, 0x9A,
-      0x45, 0x66, 0xBB, 0xBB, 0x45, 0x45, 0x60, 0xA0,
-      0xA0, 0x60, 0xA0, 0x60, 0x60, 0xA0, 0x8B, 0xBE,
-      0x75, 0x42, 0xBE, 0x8B, 0x42, 0x75, 0x66, 0xAA,
-      0x9A, 0x56, 0xAA, 0x66, 0x56, 0x9A, 0x70, 0xB5,
-      0x90, 0x4B, 0xB5, 0x70, 0x4B, 0x90, 0xBE, 0xCF,
-      0x42, 0x31, 0xCF, 0xBE, 0x31, 0x42, 0xAB, 0xD0,
-      0x55, 0x30, 0xD0, 0xAB, 0x30, 0x55, 0xD1, 0xD1,
-      0x2F, 0x2F, 0x9A, 0xD3, 0x66, 0x2D, 0xD3, 0x9A,
-      0x2D, 0x66, 0x7B, 0xC5, 0x85, 0x3B, 0xC5, 0x7B,
-      0x3B, 0x85, 0x54, 0xB4, 0xAC, 0x4C, 0xB4, 0x54,
-      0x4C, 0xAC, 0x5E, 0xBE, 0xA2, 0x42, 0xBE, 0x5E,
-      0x42, 0xA2, 0x87, 0xD8, 0x79, 0x28, 0xD8, 0x87,
-      0x28, 0x79, 0xC0, 0xE8, 0x40, 0x18, 0xE8, 0xC0,
-      0x18, 0x40, 0xD5, 0xE8, 0x2B, 0x18, 0xE8, 0xD5,
-      0x18, 0x2B, 0xAB, 0xE9, 0x55, 0x17, 0xE9, 0xAB,
-      0x17, 0x55, 0x68, 0xCD, 0x98, 0x33, 0xCD, 0x68,
-      0x33, 0x98, 0xEA, 0xEA, 0x16, 0x16, 0x80, 0x80, },
-    { 0x80, 0x80, 0x86, 0x86, 0x7A, 0x7A, 0x7E, 0x88,
-      0x82, 0x78, 0x88, 0x7E, 0x78, 0x82, 0x92, 0x92,
-      0x6E, 0x6E, 0x85, 0x92, 0x7B, 0x6E, 0x92, 0x85,
-      0x6E, 0x7B, 0x73, 0x8D, 0x8D, 0x73, 0x8D, 0x73,
-      0x73, 0x8D, 0x91, 0x9E, 0x6F, 0x62, 0x9E, 0x91,
-      0x62, 0x6F, 0x79, 0x97, 0x87, 0x69, 0x97, 0x79,
-      0x69, 0x87, 0xA0, 0xA0, 0x60, 0x60, 0x83, 0xA2,
-      0x7D, 0x5E, 0xA2, 0x83, 0x5E, 0x7D, 0xA0, 0xB0,
-      0x60, 0x50, 0xB0, 0xA0, 0x50, 0x60, 0xB1, 0xB1,
-      0x4F, 0x4F, 0x8F, 0xB2, 0x71, 0x4E, 0xB2, 0x8F,
-      0x4E, 0x71, 0x6B, 0x9E, 0x95, 0x62, 0x9E, 0x6B,
-      0x62, 0x95, 0x74, 0xA9, 0x8C, 0x57, 0xA9, 0x74,
-      0x57, 0x8C, 0x7F, 0xB8, 0x81, 0x48, 0xB8, 0x7F,
-      0x48, 0x81, 0xB4, 0xC5, 0x4C, 0x3B, 0xC5, 0xB4,
-      0x3B, 0x4C, 0x9F, 0xC6, 0x61, 0x3A, 0xC6, 0x9F,
-      0x3A, 0x61, 0xC6, 0xC6, 0x3A, 0x3A, 0x59, 0xA7,
-      0xA7, 0x59, 0xA7, 0x59, 0x59, 0xA7, 0x8D, 0xCA,
-      0x73, 0x36, 0xCA, 0x8D, 0x36, 0x73, 0x61, 0xB2,
-      0x9F, 0x4E, 0xB2, 0x61, 0x4E, 0x9F, 0x6D, 0xBF,
-      0x93, 0x41, 0xBF, 0x6D, 0x41, 0x93, 0xCA, 0xDF,
-      0x36, 0x21, 0xDF, 0xCA, 0x21, 0x36, 0xB3, 0xDF,
-      0x4D, 0x21, 0xDF, 0xB3, 0x21, 0x4D, 0xE1, 0xE1,
-      0x1F, 0x1F, 0x9F, 0xE3, 0x61, 0x1D, 0xE3, 0x9F,
-      0x1D, 0x61, 0x7A, 0xD3, 0x86, 0x2D, 0xD3, 0x7A,
-      0x2D, 0x86, 0x4C, 0xBE, 0xB4, 0x42, 0xBE, 0x4C,
-      0x42, 0xB4, 0x57, 0xCA, 0xA9, 0x36, 0xCA, 0x57,
-      0x36, 0xA9, 0x88, 0xE9, 0x78, 0x17, 0xE9, 0x88,
-      0x17, 0x78, 0xCC, 0xFB, 0x34, 0x05, 0xFB, 0xCC,
-      0x05, 0x34, 0xE6, 0xFB, 0x1A, 0x05, 0xFB, 0xE6,
-      0x05, 0x1A, 0xB4, 0xFD, 0x4C, 0x03, 0xFD, 0xB4,
-      0x03, 0x4C, 0x63, 0xDC, 0x9D, 0x24, 0xDC, 0x63,
-      0x24, 0x9D, 0xFE, 0xFE, 0x02, 0x02, 0x80, 0x80, },
-    { 0x80, 0x80, 0x87, 0x87, 0x79, 0x79, 0x7E, 0x89,
-      0x82, 0x77, 0x89, 0x7E, 0x77, 0x82, 0x95, 0x95,
-      0x6B, 0x6B, 0x86, 0x96, 0x7A, 0x6A, 0x96, 0x86,
-      0x6A, 0x7A, 0x70, 0x90, 0x90, 0x70, 0x90, 0x70,
-      0x70, 0x90, 0x94, 0xA4, 0x6C, 0x5C, 0xA4, 0x94,
-      0x5C, 0x6C, 0x78, 0x9B, 0x88, 0x65, 0x9B, 0x78,
-      0x65, 0x88, 0xA6, 0xA6, 0x5A, 0x5A, 0x83, 0xA9,
-      0x7D, 0x57, 0xA9, 0x83, 0x57, 0x7D, 0xA6, 0xB9,
-      0x5A, 0x47, 0xB9, 0xA6, 0x47, 0x5A, 0xBA, 0xBA,
-      0x46, 0x46, 0x92, 0xBC, 0x6E, 0x44, 0xBC, 0x92,
-      0x44, 0x6E, 0x67, 0xA3, 0x99, 0x5D, 0xA3, 0x67,
-      0x5D, 0x99, 0x72, 0xB0, 0x8E, 0x50, 0xB0, 0x72,
-      0x50, 0x8E, 0x7F, 0xC3, 0x81, 0x3D, 0xC3, 0x7F,
-      0x3D, 0x81, 0xBE, 0xD2, 0x42, 0x2E, 0xD2, 0xBE,
-      0x2E, 0x42, 0xA5, 0xD4, 0x5B, 0x2C, 0xD4, 0xA5,
-      0x2C, 0x5B, 0xD4, 0xD4, 0x2C, 0x2C, 0x52, 0xAE,
-      0xAE, 0x52, 0xAE, 0x52, 0x52, 0xAE, 0x8F, 0xD8,
-      0x71, 0x28, 0xD8, 0x8F, 0x28, 0x71, 0x5B, 0xBB,
-      0xA5, 0x45, 0xBB, 0x5B, 0x45, 0xA5, 0x69, 0xCB,
-      0x97, 0x35, 0xCB, 0x69, 0x35, 0x97, 0xD8, 0xF0,
-      0x28, 0x10, 0xF0, 0xD8, 0x10, 0x28, 0xBD, 0xF1,
-      0x43, 0x0F, 0xF1, 0xBD, 0x0F, 0x43, 0xF3, 0xF3,
-      0x0D, 0x0D, 0xA5, 0xF6, 0x5B, 0x0A, 0xF6, 0xA5,
-      0x0A, 0x5B, 0x78, 0xE2, 0x88, 0x1E, 0xE2, 0x78,
-      0x1E, 0x88, 0x42, 0xC9, 0xBE, 0x37, 0xC9, 0x42,
-      0x37, 0xBE, 0x4F, 0xD8, 0xB1, 0x28, 0xD8, 0x4F,
-      0x28, 0xB1, 0x8A, 0xFD, 0x76, 0x03, 0xFD, 0x8A,
-      0x03, 0x76, 0xDB, 0xFF, 0x25, 0x01, 0xFF, 0xDB,
-      0x01, 0x25, 0xF9, 0xFF, 0x07, 0x01, 0xFF, 0xF9,
-      0x01, 0x07, 0xBE, 0xFF, 0x42, 0x01, 0xFF, 0xBE,
-      0x01, 0x42, 0x5E, 0xED, 0xA2, 0x13, 0xED, 0x5E,
-      0x13, 0xA2, 0xFF, 0xFF, 0x01, 0x01, 0x80, 0x80, },
+static const uint8_t ir2_luma_table[256] = {
+ 0x80, 0x80, 0x84, 0x84, 0x7C, 0x7C, 0x7F, 0x85,
+ 0x81, 0x7B, 0x85, 0x7F, 0x7B, 0x81, 0x8C, 0x8C,
+ 0x74, 0x74, 0x83, 0x8D, 0x7D, 0x73, 0x8D, 0x83,
+ 0x73, 0x7D, 0x77, 0x89, 0x89, 0x77, 0x89, 0x77,
+ 0x77, 0x89, 0x8C, 0x95, 0x74, 0x6B, 0x95, 0x8C,
+ 0x6B, 0x74, 0x7C, 0x90, 0x84, 0x70, 0x90, 0x7C,
+ 0x70, 0x84, 0x96, 0x96, 0x6A, 0x6A, 0x82, 0x98,
+ 0x7E, 0x68, 0x98, 0x82, 0x68, 0x7E, 0x97, 0xA2,
+ 0x69, 0x5E, 0xA2, 0x97, 0x5E, 0x69, 0xA2, 0xA2,
+ 0x5E, 0x5E, 0x8B, 0xA3, 0x75, 0x5D, 0xA3, 0x8B,
+ 0x5D, 0x75, 0x71, 0x95, 0x8F, 0x6B, 0x95, 0x71,
+ 0x6B, 0x8F, 0x78, 0x9D, 0x88, 0x63, 0x9D, 0x78,
+ 0x63, 0x88, 0x7F, 0xA7, 0x81, 0x59, 0xA7, 0x7F,
+ 0x59, 0x81, 0xA4, 0xB1, 0x5C, 0x4F, 0xB1, 0xA4,
+ 0x4F, 0x5C, 0x96, 0xB1, 0x6A, 0x4F, 0xB1, 0x96,
+ 0x4F, 0x6A, 0xB2, 0xB2, 0x4E, 0x4E, 0x65, 0x9B,
+ 0x9B, 0x65, 0x9B, 0x65, 0x65, 0x9B, 0x89, 0xB4,
+ 0x77, 0x4C, 0xB4, 0x89, 0x4C, 0x77, 0x6A, 0xA3,
+ 0x96, 0x5D, 0xA3, 0x6A, 0x5D, 0x96, 0x73, 0xAC,
+ 0x8D, 0x54, 0xAC, 0x73, 0x54, 0x8D, 0xB4, 0xC3,
+ 0x4C, 0x3D, 0xC3, 0xB4, 0x3D, 0x4C, 0xA4, 0xC3,
+ 0x5C, 0x3D, 0xC3, 0xA4, 0x3D, 0x5C, 0xC4, 0xC4,
+ 0x3C, 0x3C, 0x96, 0xC6, 0x6A, 0x3A, 0xC6, 0x96,
+ 0x3A, 0x6A, 0x7C, 0xBA, 0x84, 0x46, 0xBA, 0x7C,
+ 0x46, 0x84, 0x5B, 0xAB, 0xA5, 0x55, 0xAB, 0x5B,
+ 0x55, 0xA5, 0x63, 0xB4, 0x9D, 0x4C, 0xB4, 0x63,
+ 0x4C, 0x9D, 0x86, 0xCA, 0x7A, 0x36, 0xCA, 0x86,
+ 0x36, 0x7A, 0xB6, 0xD7, 0x4A, 0x29, 0xD7, 0xB6,
+ 0x29, 0x4A, 0xC8, 0xD7, 0x38, 0x29, 0xD7, 0xC8,
+ 0x29, 0x38, 0xA4, 0xD8, 0x5C, 0x28, 0xD8, 0xA4,
+ 0x28, 0x5C, 0x6C, 0xC1, 0x94, 0x3F, 0xC1, 0x6C,
+ 0x3F, 0x94, 0xD9, 0xD9, 0x27, 0x27, 0x80, 0x80
 };

 #endif /* AVCODEC_INDEO2DATA_H */
--- a/libavcodec/j2kenc.c
+++ b/libavcodec/j2kenc.c
@@ -17,46 +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
- *
- * **********************************************************************************************************************
- *
- *
- *
- * This source code incorporates work covered by the following copyright and
- * permission notice:
- *
- * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
- * Copyright (c) 2002-2007, Professor Benoit Macq
- * Copyright (c) 2001-2003, David Janssens
- * Copyright (c) 2002-2003, Yannick Verschueren
- * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
- * Copyright (c) 2005, Herve Drolon, FreeImage Team
- * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
 */

-
 /**
 * JPEG2000 image encoder
 * @file
--- a/libavcodec/libutvideodec.cpp
+++ b/libavcodec/libutvideodec.cpp
@@ -222,19 +222,9 @@ static int utvideo_decode_frame(AVCodecContext *avctx, void *data,
        pic->data[0] = utv->buffer + utv->buf_size + pic->linesize[0];
        break;
    }
-    pic->width  = w;
-    pic->height = h;
-    pic->format = avctx->pix_fmt;
-
-    if (avctx->refcounted_frames) {
-        int ret = av_frame_ref((AVFrame*)data, pic);
-        if (ret < 0)
-             return ret;
-    } else {
-        av_frame_move_ref((AVFrame*)data, pic);
-    }

    *got_frame = 1;
+    av_frame_move_ref((AVFrame*)data, pic);

    return avpkt->size;
 }
--- a/libavcodec/libwebpenc_animencoder.c
+++ b/libavcodec/libwebpenc_animencoder.c
@@ -41,9 +41,8 @@ static av_cold int libwebp_anim_encode_init(AVCodecContext *avctx)
    int ret = ff_libwebp_encode_init_common(avctx);
    if (!ret) {
        LibWebPAnimContext *s = avctx->priv_data;
-        WebPAnimEncoderOptions enc_options = { 0 };
+        WebPAnimEncoderOptions enc_options;
        WebPAnimEncoderOptionsInit(&enc_options);
-        enc_options.verbose = av_log_get_level() >= AV_LOG_VERBOSE;
        // TODO(urvang): Expose some options on command-line perhaps.
        s->enc = WebPAnimEncoderNew(avctx->width, avctx->height, &enc_options);
        if (!s->enc)
--- a/libavcodec/mips/aaccoder_mips.c
+++ b/libavcodec/mips/aaccoder_mips.c
@@ -66,7 +66,6 @@
 #include "libavcodec/aacenc_utils.h"

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 typedef struct BandCodingPath {
    int prev_idx;
    float cost;
@@ -2478,12 +2477,10 @@ static void search_for_ms_mips(AACEncContext *s, ChannelElement *cpe)

 #include "libavcodec/aaccoder_trellis.h"

-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */

 void ff_aac_coder_init_mips(AACEncContext *c) {
 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    AACCoefficientsEncoder *e = c->coder;
    int option = c->options.coder;

@@ -2497,6 +2494,5 @@ void ff_aac_coder_init_mips(AACEncContext *c) {
 #if HAVE_MIPSFPU
    e->search_for_ms            = search_for_ms_mips;
 #endif /* HAVE_MIPSFPU */
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */
 }
--- a/libavcodec/mips/aacdec_mips.h
+++ b/libavcodec/mips/aacdec_mips.h
@@ -61,7 +61,6 @@
 #include "libavutil/mips/asmdefs.h"

 #if HAVE_INLINE_ASM && HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static inline float *VMUL2_mips(float *dst, const float *v, unsigned idx,
                           const float *scale)
 {
@@ -247,7 +246,6 @@ static inline float *VMUL4S_mips(float *dst, const float *v, unsigned idx,
 #define VMUL4 VMUL4_mips
 #define VMUL2S VMUL2S_mips
 #define VMUL4S VMUL4S_mips
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM && HAVE_MIPSFPU */

 #endif /* AVCODEC_MIPS_AACDEC_MIPS_H */
--- a/libavcodec/mips/aacpsdsp_mips.c
+++ b/libavcodec/mips/aacpsdsp_mips.c
@@ -188,7 +188,6 @@ static void ps_hybrid_synthesis_deint_mips(float out[2][38][64],
 }

 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void ps_add_squares_mips(float *dst, const float (*src)[2], int n)
 {
    int i;
@@ -443,7 +442,6 @@ static void ps_stereo_interpolate_mips(float (*l)[2], float (*r)[2],
        : "memory"
    );
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_MIPSFPU */
 #endif /* HAVE_INLINE_ASM */

@@ -453,12 +451,10 @@ void ff_psdsp_init_mips(PSDSPContext *s)
    s->hybrid_analysis_ileave = ps_hybrid_analysis_ileave_mips;
    s->hybrid_synthesis_deint = ps_hybrid_synthesis_deint_mips;
 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    s->add_squares            = ps_add_squares_mips;
    s->mul_pair_single        = ps_mul_pair_single_mips;
    s->decorrelate            = ps_decorrelate_mips;
    s->stereo_interpolate[0]  = ps_stereo_interpolate_mips;
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_MIPSFPU */
 #endif /* HAVE_INLINE_ASM */
 }
--- a/libavcodec/mips/aacpsy_mips.h
+++ b/libavcodec/mips/aacpsy_mips.h
@@ -59,7 +59,6 @@
 #include "libavutil/mips/asmdefs.h"

 #if HAVE_INLINE_ASM && HAVE_MIPSFPU && ( PSY_LAME_FIR_LEN == 21 )
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void calc_thr_3gpp_mips(const FFPsyWindowInfo *wi, const int num_bands,
                               AacPsyChannel *pch, const uint8_t *band_sizes,
                               const float *coefs, const int cutoff)
@@ -233,6 +232,5 @@ static void psy_hp_filter_mips(const float *firbuf, float *hpfsmpl, const float
 #define calc_thr_3gpp calc_thr_3gpp_mips
 #define psy_hp_filter psy_hp_filter_mips

-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM && HAVE_MIPSFPU */
 #endif /* AVCODEC_MIPS_AACPSY_MIPS_H */
--- a/libavcodec/mips/aacsbr_mips.c
+++ b/libavcodec/mips/aacsbr_mips.c
@@ -311,7 +311,6 @@ static int sbr_x_gen_mips(SpectralBandReplication *sbr, float X[2][38][64],
 }

 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void sbr_hf_assemble_mips(float Y1[38][64][2],
                            const float X_high[64][40][2],
                            SpectralBandReplication *sbr, SBRData *ch_data,
@@ -604,7 +603,6 @@ static void sbr_hf_inverse_filter_mips(SBRDSPContext *dsp,
        }
    }
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_MIPSFPU */
 #endif /* HAVE_INLINE_ASM */

@@ -614,10 +612,8 @@ void ff_aacsbr_func_ptr_init_mips(AACSBRContext *c)
    c->sbr_lf_gen            = sbr_lf_gen_mips;
    c->sbr_x_gen             = sbr_x_gen_mips;
 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    c->sbr_hf_inverse_filter = sbr_hf_inverse_filter_mips;
    c->sbr_hf_assemble       = sbr_hf_assemble_mips;
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_MIPSFPU */
 #endif /* HAVE_INLINE_ASM */
 }
--- a/libavcodec/mips/aacsbr_mips.h
+++ b/libavcodec/mips/aacsbr_mips.h
@@ -150,7 +150,6 @@ static void sbr_qmf_analysis_mips(AVFloatDSPContext *fdsp, FFTContext *mdct,
 }

 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void sbr_qmf_synthesis_mips(FFTContext *mdct,
                              SBRDSPContext *sbrdsp, AVFloatDSPContext *fdsp,
                              float *out, float X[2][38][64],
@@ -489,7 +488,6 @@ static void sbr_qmf_synthesis_mips(FFTContext *mdct,
 #define sbr_qmf_analysis sbr_qmf_analysis_mips
 #define sbr_qmf_synthesis sbr_qmf_synthesis_mips

-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_MIPSFPU */
 #endif /* HAVE_INLINE_ASM */

--- a/libavcodec/mips/ac3dsp_mips.c
+++ b/libavcodec/mips/ac3dsp_mips.c
@@ -201,7 +201,6 @@ static void ac3_update_bap_counts_mips(uint16_t mant_cnt[16], uint8_t *bap,
 #endif

 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void float_to_fixed24_mips(int32_t *dst, const float *src, unsigned int len)
 {
    const float scale = 1 << 24;
@@ -396,8 +395,7 @@ static void ac3_downmix_mips(float **samples, float (*matrix)[2],
        :"memory"
    );
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
-#endif /* HAVE_MIPSFPU */
+#endif
 #endif /* HAVE_INLINE_ASM */

 void ff_ac3dsp_init_mips(AC3DSPContext *c, int bit_exact) {
@@ -407,11 +405,9 @@ void ff_ac3dsp_init_mips(AC3DSPContext *c, int bit_exact) {
    c->update_bap_counts  = ac3_update_bap_counts_mips;
 #endif
 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    c->float_to_fixed24 = float_to_fixed24_mips;
    c->downmix          = ac3_downmix_mips;
 #endif
 #endif

-#endif
 }
--- a/libavcodec/mips/acelp_filters_mips.c
+++ b/libavcodec/mips/acelp_filters_mips.c
@@ -57,7 +57,6 @@
 #include "libavutil/mips/asmdefs.h"

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void ff_acelp_interpolatef_mips(float *out, const float *in,
                           const float *filter_coeffs, int precision,
                           int frac_pos, int filter_length, int length)
@@ -207,15 +206,12 @@ static void ff_acelp_apply_order_2_transfer_function_mips(float *out, const floa
           "$f12", "$f13", "$f14", "$f15", "$f16", "memory"
    );
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */

 void ff_acelp_filter_init_mips(ACELPFContext *c)
 {
 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    c->acelp_interpolatef                      = ff_acelp_interpolatef_mips;
    c->acelp_apply_order_2_transfer_function   = ff_acelp_apply_order_2_transfer_function_mips;
 #endif
-#endif
 }
--- a/libavcodec/mips/acelp_vectors_mips.c
+++ b/libavcodec/mips/acelp_vectors_mips.c
@@ -57,7 +57,6 @@
 #include "libavutil/mips/asmdefs.h"

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void ff_weighted_vector_sumf_mips(
                  float *out, const float *in_a, const float *in_b,
                  float weight_coeff_a, float weight_coeff_b, int length)
@@ -93,14 +92,11 @@ static void ff_weighted_vector_sumf_mips(
        : "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "memory"
    );
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */

 void ff_acelp_vectors_init_mips(ACELPVContext *c)
 {
 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    c->weighted_vector_sumf = ff_weighted_vector_sumf_mips;
 #endif
-#endif
 }
--- a/libavcodec/mips/amrwbdec_mips.c
+++ b/libavcodec/mips/amrwbdec_mips.c
@@ -54,7 +54,6 @@
 #include "amrwbdec_mips.h"

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 void ff_hb_fir_filter_mips(float *out, const float fir_coef[HB_FIR_SIZE + 1],
                          float mem[HB_FIR_SIZE], const float *in)
 {
@@ -185,5 +184,4 @@ void ff_hb_fir_filter_mips(float *out, const float fir_coef[HB_FIR_SIZE + 1],
    }
    memcpy(mem, data + AMRWB_SFR_SIZE_16k, HB_FIR_SIZE * sizeof(float));
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */
--- a/libavcodec/mips/amrwbdec_mips.h
+++ b/libavcodec/mips/amrwbdec_mips.h
@@ -54,11 +54,9 @@
 #include "config.h"

 #if HAVE_MIPSFPU && HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 void ff_hb_fir_filter_mips(float *out, const float fir_coef[],
                          float mem[], const float *in);
 #define hb_fir_filter ff_hb_fir_filter_mips
 #endif
-#endif

 #endif /* AVCODEC_MIPS_AMRWBDEC_MIPS_H  */
--- a/libavcodec/mips/celp_filters_mips.c
+++ b/libavcodec/mips/celp_filters_mips.c
@@ -58,7 +58,6 @@
 #include "libavutil/mips/asmdefs.h"

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void ff_celp_lp_synthesis_filterf_mips(float *out,
                                  const float *filter_coeffs,
                                  const float* in, int buffer_length,
@@ -279,15 +278,12 @@ static void ff_celp_lp_zero_synthesis_filterf_mips(float *out,
        out[n] = sum_out1;
    }
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */

 void ff_celp_filter_init_mips(CELPFContext *c)
 {
 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    c->celp_lp_synthesis_filterf        = ff_celp_lp_synthesis_filterf_mips;
    c->celp_lp_zero_synthesis_filterf   = ff_celp_lp_zero_synthesis_filterf_mips;
 #endif
-#endif
 }
--- a/libavcodec/mips/celp_math_mips.c
+++ b/libavcodec/mips/celp_math_mips.c
@@ -56,7 +56,6 @@
 #include "libavutil/mips/asmdefs.h"

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static float ff_dot_productf_mips(const float* a, const float* b,
                                              int length)
 {
@@ -81,14 +80,11 @@ static float ff_dot_productf_mips(const float* a, const float* b,
    );
    return sum;
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */

 void ff_celp_math_init_mips(CELPMContext *c)
 {
 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    c->dot_productf = ff_dot_productf_mips;
 #endif
-#endif
 }
--- a/libavcodec/mips/compute_antialias_float.h
+++ b/libavcodec/mips/compute_antialias_float.h
@@ -58,7 +58,6 @@
 #include "libavutil/mips/asmdefs.h"

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void compute_antialias_mips_float(MPADecodeContext *s,
                                        GranuleDef *g)
 {
@@ -180,7 +179,6 @@ static void compute_antialias_mips_float(MPADecodeContext *s,
    );
 }
 #define compute_antialias compute_antialias_mips_float
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */

 #endif /* AVCODEC_MIPS_COMPUTE_ANTIALIAS_FLOAT_H */
--- a/libavcodec/mips/fft_mips.c
+++ b/libavcodec/mips/fft_mips.c
@@ -57,7 +57,6 @@
 */

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void ff_fft_calc_mips(FFTContext *s, FFTComplex *z)
 {
    int nbits, i, n, num_transforms, offset, step;
@@ -495,7 +494,6 @@ static void ff_imdct_calc_mips(FFTContext *s, FFTSample *output, const FFTSample
        output[n-k-4] = output[n2+k+3];
    }
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */

 av_cold void ff_fft_init_mips(FFTContext *s)
@@ -506,12 +504,10 @@ av_cold void ff_fft_init_mips(FFTContext *s)
    ff_init_ff_cos_tabs(16);

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    s->fft_calc     = ff_fft_calc_mips;
 #if CONFIG_MDCT
    s->imdct_calc   = ff_imdct_calc_mips;
    s->imdct_half   = ff_imdct_half_mips;
 #endif
 #endif
-#endif
 }
--- a/libavcodec/mips/iirfilter_mips.c
+++ b/libavcodec/mips/iirfilter_mips.c
@@ -55,7 +55,6 @@
 #include "libavcodec/iirfilter.h"

 #if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 typedef struct FFIIRFilterCoeffs {
    int   order;
    float gain;
@@ -196,13 +195,10 @@ static void ff_iir_filter_flt_mips(const struct FFIIRFilterCoeffs *c,
        }
    }
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */

 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;
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */
 }
--- a/libavcodec/mips/lsp_mips.h
+++ b/libavcodec/mips/lsp_mips.h
@@ -55,7 +55,6 @@
 #define AVCODEC_MIPS_LSP_MIPS_H

 #if HAVE_MIPSFPU && HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 #include "libavutil/mips/asmdefs.h"

 static av_always_inline void ff_lsp2polyf_mips(const double *lsp, double *f, int lp_half_order)
@@ -108,6 +107,5 @@ static av_always_inline void ff_lsp2polyf_mips(const double *lsp, double *f, int
    }
 }
 #define ff_lsp2polyf ff_lsp2polyf_mips
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_MIPSFPU && HAVE_INLINE_ASM */
 #endif /* AVCODEC_MIPS_LSP_MIPS_H */
--- a/libavcodec/mips/mpegaudiodsp_mips_fixed.c
+++ b/libavcodec/mips/mpegaudiodsp_mips_fixed.c
@@ -57,9 +57,6 @@
 #include "libavutil/mips/asmdefs.h"
 #include "libavcodec/mpegaudiodsp.h"

-#if HAVE_INLINE_ASM
-#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)
 {
@@ -904,15 +901,8 @@ static void ff_imdct36_blocks_mips_fixed(int *out, int *buf, int *in,
    }
 }

-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
-#endif /* HAVE_INLINE_ASM */
-
 void ff_mpadsp_init_mipsdsp(MPADSPContext *s)
 {
-#if HAVE_INLINE_ASM
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    s->apply_window_fixed   = ff_mpadsp_apply_window_mips_fixed;
    s->imdct36_blocks_fixed = ff_imdct36_blocks_mips_fixed;
-#endif
-#endif
 }
--- a/libavcodec/mips/mpegaudiodsp_mips_float.c
+++ b/libavcodec/mips/mpegaudiodsp_mips_float.c
@@ -58,9 +58,6 @@
 #include "libavutil/mips/asmdefs.h"
 #include "libavcodec/mpegaudiodsp.h"

-#if HAVE_INLINE_ASM && HAVE_MIPSFPU
-#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)
 {
@@ -1246,16 +1243,9 @@ static void ff_imdct36_blocks_mips_float(float *out, float *buf, float *in,
    }
 }

-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
-#endif /* HAVE_INLINE_ASM && HAVE_MIPSFPU */
-
 void ff_mpadsp_init_mipsfpu(MPADSPContext *s)
 {
-#if HAVE_INLINE_ASM && HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    s->apply_window_float   = ff_mpadsp_apply_window_mips_float;
    s->imdct36_blocks_float = ff_imdct36_blocks_mips_float;
    s->dct32_float          = ff_dct32_mips_float;
-#endif
-#endif
 }
--- a/libavcodec/mips/sbrdsp_mips.c
+++ b/libavcodec/mips/sbrdsp_mips.c
@@ -166,7 +166,6 @@ static void sbr_qmf_post_shuffle_mips(float W[32][2], const float *z)
 }

 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void sbr_sum64x5_mips(float *z)
 {
    int k;
@@ -883,7 +882,6 @@ static void sbr_hf_apply_noise_3_mips(float (*Y)[2], const float *s_m,
       phi_sign = -phi_sign;
    }
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_MIPSFPU */
 #endif /* HAVE_INLINE_ASM */

@@ -893,7 +891,6 @@ void ff_sbrdsp_init_mips(SBRDSPContext *s)
    s->qmf_pre_shuffle = sbr_qmf_pre_shuffle_mips;
    s->qmf_post_shuffle = sbr_qmf_post_shuffle_mips;
 #if HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    s->sum64x5 = sbr_sum64x5_mips;
    s->sum_square = sbr_sum_square_mips;
    s->qmf_deint_bfly = sbr_qmf_deint_bfly_mips;
@@ -905,7 +902,6 @@ void ff_sbrdsp_init_mips(SBRDSPContext *s)
    s->hf_apply_noise[1] = sbr_hf_apply_noise_1_mips;
    s->hf_apply_noise[2] = sbr_hf_apply_noise_2_mips;
    s->hf_apply_noise[3] = sbr_hf_apply_noise_3_mips;
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_MIPSFPU */
 #endif /* HAVE_INLINE_ASM */
 }
--- a/libavcodec/mjpegdec.c
+++ b/libavcodec/mjpegdec.c
@@ -1381,10 +1381,12 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
        return AVERROR_INVALIDDATA;
    }

-    // s->coefs_finished is a bitmask for coefficients coded
-    // ss and se are parameters telling start and end coefficients
-    s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
-    last_scan = !Al && !~s->coefs_finished[c];
+    if (!Al) {
+        // s->coefs_finished is a bitmask for coefficients coded
+        // ss and se are parameters telling start and end coefficients
+        s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
+        last_scan = !~s->coefs_finished[c];
+    }

    if (s->interlaced && s->bottom_field)
        data += linesize >> 1;
--- a/libavcodec/mjpegenc_common.c
+++ b/libavcodec/mjpegenc_common.c
@@ -122,16 +122,6 @@ static void jpeg_put_comments(AVCodecContext *avctx, PutBitContext *p)
    uint8_t *ptr;

    if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
-        AVRational sar = avctx->sample_aspect_ratio;
-
-        if (sar.num > 65535 || sar.den > 65535) {
-            if (!av_reduce(&sar.num, &sar.den, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 65535))
-                av_log(avctx, AV_LOG_WARNING,
-                    "Cannot store exact aspect ratio %d:%d\n",
-                    avctx->sample_aspect_ratio.num,
-                    avctx->sample_aspect_ratio.den);
-        }
-
        /* JFIF header */
        put_marker(p, APP0);
        put_bits(p, 16, 16);
@@ -141,8 +131,8 @@ static void jpeg_put_comments(AVCodecContext *avctx, PutBitContext *p)
         * released revision. */
        put_bits(p, 16, 0x0102);
        put_bits(p,  8, 0);              /* units type: 0 - aspect ratio */
-        put_bits(p, 16, sar.num);
-        put_bits(p, 16, sar.den);
+        put_bits(p, 16, avctx->sample_aspect_ratio.num);
+        put_bits(p, 16, avctx->sample_aspect_ratio.den);
        put_bits(p, 8, 0); /* thumbnail width */
        put_bits(p, 8, 0); /* thumbnail height */
    }
--- a/libavcodec/pgssubdec.c
+++ b/libavcodec/pgssubdec.c
@@ -354,14 +354,8 @@ static int parse_palette_segment(AVCodecContext *avctx,
        cb        = bytestream_get_byte(&buf);
        alpha     = bytestream_get_byte(&buf);

-        /* Default to BT.709 colorimetry. In case of <= 576 height use BT.601 */
-        if (avctx->height <= 0 || avctx->height > 576) {
-            YUV_TO_RGB1_CCIR_BT709(cb, cr);
-        } else {
-            YUV_TO_RGB1_CCIR(cb, cr);
-        }
-
-        YUV_TO_RGB2_CCIR(r, g, b, y);
+        YUV_TO_RGB1(cb, cr);
+        YUV_TO_RGB2(r, g, b, y);

        ff_dlog(avctx, "Color %d := (%d,%d,%d,%d)\n", color_id, r, g, b, alpha);

--- a/libavcodec/pngdec.c
+++ b/libavcodec/pngdec.c
@@ -1136,7 +1136,6 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
            case MKTAG('p', 'H', 'Y', 's'):
            case MKTAG('t', 'E', 'X', 't'):
            case MKTAG('I', 'D', 'A', 'T'):
-            case MKTAG('t', 'R', 'N', 'S'):
                break;
            default:
                goto skip_tag;
--- a/libavcodec/resample.c
+++ b/libavcodec/resample.c
@@ -291,6 +291,12 @@ int audio_resample(ReSampleContext *s, short *output, short *input, int nb_sampl
    short *output_bak = NULL;
    int lenout;

+    if (s->input_channels == s->output_channels && s->ratio == 1.0 && 0) {
+        /* nothing to do */
+        memcpy(output, input, nb_samples * s->input_channels * sizeof(short));
+        return nb_samples;
+    }
+
    if (s->sample_fmt[0] != AV_SAMPLE_FMT_S16) {
        int istride[1] = { s->sample_size[0] };
        int ostride[1] = { 2 };
--- a/libavcodec/takdec.c
+++ b/libavcodec/takdec.c
@@ -227,7 +227,6 @@ static void decode_lpc(int32_t *coeffs, int mode, int length)
            int a3  = coeffs[2];
            int a4  = a3 + a1;
            int a5  = a4 + a2;
-            coeffs[2] = a5;
            coeffs += 3;
            for (i = 0; i < length - 3; i++) {
                a3     += *coeffs;
--- a/libavcodec/ttaenc.c
+++ b/libavcodec/ttaenc.c
@@ -114,12 +114,9 @@ static int tta_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 {
    TTAEncContext *s = avctx->priv_data;
    PutBitContext pb;
-    int ret, i, out_bytes, cur_chan, res, samples;
-    int64_t pkt_size =  frame->nb_samples * 2LL * avctx->channels * s->bps;
+    int ret, i, out_bytes, cur_chan = 0, res = 0, samples = 0;

-pkt_alloc:
-    cur_chan = 0, res = 0, samples = 0;
-    if ((ret = ff_alloc_packet2(avctx, avpkt, pkt_size, 0)) < 0)
+    if ((ret = ff_alloc_packet2(avctx, avpkt, frame->nb_samples * 2 * avctx->channels * s->bps, 0)) < 0)
        return ret;
    init_put_bits(&pb, avpkt->data, avpkt->size);

@@ -177,14 +174,6 @@ pkt_alloc:
                rice->k1++;

            unary = 1 + (outval >> k);
-            if (unary + 100LL > put_bits_left(&pb)) {
-                if (pkt_size < INT_MAX/2) {
-                    pkt_size *= 2;
-                    av_packet_unref(avpkt);
-                    goto pkt_alloc;
-                } else
-                    return AVERROR(ENOMEM);
-            }
            do {
                if (unary > 31) {
                    put_bits(&pb, 31, 0x7FFFFFFF);
--- a/libavcodec/vc2enc.c
+++ b/libavcodec/vc2enc.c
@@ -658,8 +658,7 @@ static int rate_control(AVCodecContext *avctx, void *arg)
    VC2EncContext *s = slice_dat->ctx;
    const int sx = slice_dat->x;
    const int sy = slice_dat->y;
-    int bits_last = INT_MAX, quant_buf[2] = {-1, -1};
-    int quant = s->q_start, range = s->q_start/3;
+    int quant_buf[2], bits_buf[2], quant = s->q_start, range = s->q_start/3;
    const int64_t top = slice_dat->bits_ceil;
    const double percent = s->tolerance;
    const double bottom = top - top*(percent/100.0f);
@@ -671,13 +670,14 @@ static int rate_control(AVCodecContext *avctx, void *arg)
        bits = count_hq_slice(s, sx, sy, quant);
        range = av_clip(range/2, 1, s->q_ceil);
        if (quant_buf[1] == quant) {
-            quant = bits_last < bits ? quant_buf[0] : quant;
-            bits  = bits_last < bits ? bits_last : bits;
+            quant = bits_buf[0] < bits ? quant_buf[0] : quant;
+            bits = bits_buf[0] < bits ? bits_buf[0] : bits;
            break;
        }
        quant_buf[1] = quant_buf[0];
        quant_buf[0] = quant;
-        bits_last = bits;
+        bits_buf[1] = bits_buf[0];
+        bits_buf[0] = bits;
    }
    slice_dat->quant_idx = av_clip(quant, 0, s->q_ceil);
    slice_dat->bytes = FFALIGN((bits >> 3), s->size_scaler) + 4 + s->prefix_bytes;
@@ -867,7 +867,7 @@ static int dwt_plane(AVCodecContext *avctx, void *arg)
        }
    }

-    memset(buf, 0, p->coef_stride * (p->dwt_height - p->height) * sizeof(dwtcoef));
+    memset(buf, 0, (p->coef_stride*p->dwt_height - p->height*p->width)*sizeof(dwtcoef));

    for (level = s->wavelet_depth-1; level >= 0; level--) {
        const SubBand *b = &p->band[level][0];
--- a/libavcodec/x86/hevcdsp_init.c
+++ b/libavcodec/x86/hevcdsp_init.c
@@ -753,10 +753,6 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
            c->transform_add[3]    = ff_hevc_transform_add32_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;
            if (ARCH_X86_64) {
@@ -901,9 +897,7 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
            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;
            if (ARCH_X86_64) {
@@ -1101,9 +1095,6 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
            SAO_BAND_INIT(12, avx);
        }
        if (EXTERNAL_AVX2(cpu_flags)) {
-            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;

--- a/libavcodec/x86/huffyuvencdsp_mmx.c
+++ b/libavcodec/x86/huffyuvencdsp_mmx.c
@@ -98,7 +98,7 @@ av_cold void ff_huffyuvencdsp_init_x86(HuffYUVEncDSPContext *c)
        c->diff_bytes = ff_diff_bytes_sse2;
    }

-    if (EXTERNAL_AVX2_FAST(cpu_flags)) {
+    if (EXTERNAL_AVX2(cpu_flags)) {
        c->diff_bytes = ff_diff_bytes_avx2;
    }
 }
--- a/libavcodec/x86/jpeg2000dsp_init.c
+++ b/libavcodec/x86/jpeg2000dsp_init.c
@@ -44,7 +44,7 @@ av_cold void ff_jpeg2000dsp_init_x86(Jpeg2000DSPContext *c)
        c->mct_decode[FF_DWT97] = ff_ict_float_avx;
    }

-    if (EXTERNAL_AVX2_FAST(cpu_flags)) {
+    if (EXTERNAL_AVX2(cpu_flags)) {
        c->mct_decode[FF_DWT53] = ff_rct_int_avx2;
    }
 }
--- a/libavcodec/x86/mlpdsp_init.c
+++ b/libavcodec/x86/mlpdsp_init.c
@@ -199,6 +199,6 @@ av_cold void ff_mlpdsp_init_x86(MLPDSPContext *c)
 #endif
    if (ARCH_X86_64 && EXTERNAL_SSE4(cpu_flags))
        c->mlp_rematrix_channel = ff_mlp_rematrix_channel_sse4;
-    if (ARCH_X86_64 && EXTERNAL_AVX2_FAST(cpu_flags) && cpu_flags & AV_CPU_FLAG_BMI2)
+    if (ARCH_X86_64 && EXTERNAL_AVX2(cpu_flags) && cpu_flags & AV_CPU_FLAG_BMI2)
        c->mlp_rematrix_channel = ff_mlp_rematrix_channel_avx2_bmi2;
 }
--- a/libavcodec/x86/synth_filter_init.c
+++ b/libavcodec/x86/synth_filter_init.c
@@ -67,7 +67,7 @@ av_cold void ff_synth_filter_init_x86(SynthFilterContext *s)
    if (EXTERNAL_AVX_FAST(cpu_flags)) {
        s->synth_filter_float = synth_filter_avx;
    }
-    if (EXTERNAL_FMA3_FAST(cpu_flags)) {
+    if (EXTERNAL_FMA3(cpu_flags) && !(cpu_flags & AV_CPU_FLAG_AVXSLOW)) {
        s->synth_filter_float = synth_filter_fma3;
    }
 #endif /* HAVE_YASM */
--- a/libavcodec/x86/v210enc_init.c
+++ b/libavcodec/x86/v210enc_init.c
@@ -45,7 +45,7 @@ av_cold void ff_v210enc_init_x86(V210EncContext *s)
    if (EXTERNAL_AVX(cpu_flags))
        s->pack_line_8 = ff_v210_planar_pack_8_avx;

-    if (EXTERNAL_AVX2_FAST(cpu_flags)) {
+    if (EXTERNAL_AVX2(cpu_flags)) {
        s->pack_line_8 = ff_v210_planar_pack_8_avx2;
        s->pack_line_10 = ff_v210_planar_pack_10_avx2;
        s->sample_factor = 2;
--- a/libavcodec/x86/vp9dsp_init.c
+++ b/libavcodec/x86/vp9dsp_init.c
@@ -377,7 +377,7 @@ av_cold void ff_vp9dsp_init_x86(VP9DSPContext *dsp, int bpp, int bitexact)
        init_ipred(32, avx, v, VERT);
    }

-    if (EXTERNAL_AVX2_FAST(cpu_flags)) {
+    if (EXTERNAL_AVX2(cpu_flags)) {
        init_fpel_func(1, 1, 32, avg, _8, avx2);
        init_fpel_func(0, 1, 64, avg, _8, avx2);
        if (ARCH_X86_64) {
--- a/libavcodec/x86/vp9dsp_init_16bpp.c
+++ b/libavcodec/x86/vp9dsp_init_16bpp.c
@@ -129,7 +129,7 @@ av_cold void ff_vp9dsp_init_16bpp_x86(VP9DSPContext *dsp)
        init_ipred_funcs(hd, HOR_DOWN, 16, avx);
    }

-    if (EXTERNAL_AVX2_FAST(cpu_flags)) {
+    if (EXTERNAL_AVX2(cpu_flags)) {
        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);
--- a/libavcodec/x86/vp9dsp_init_16bpp_template.c
+++ b/libavcodec/x86/vp9dsp_init_16bpp_template.c
@@ -225,7 +225,7 @@ av_cold void INIT_FUNC(VP9DSPContext *dsp, int bitexact)
        init_lpf_funcs(BPC, avx);
    }

-    if (EXTERNAL_AVX2_FAST(cpu_flags)) {
+    if (EXTERNAL_AVX2(cpu_flags)) {
 #if HAVE_AVX2_EXTERNAL
        init_subpel3_32_64(0,  put, BPC, avx2);
        init_subpel3_32_64(1,  avg, BPC, avx2);
--- a/libavfilter/src_movie.c
+++ b/libavfilter/src_movie.c
@@ -240,7 +240,7 @@ static av_cold int movie_common_init(AVFilterContext *ctx)
        timestamp = movie->seek_point;
        // add the stream start time, should it exist
        if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
-            if (timestamp > 0 && movie->format_ctx->start_time > INT64_MAX - timestamp) {
+            if (timestamp > INT64_MAX - movie->format_ctx->start_time) {
                av_log(ctx, AV_LOG_ERROR,
                       "%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
                       movie->file_name, movie->format_ctx->start_time, movie->seek_point);
--- a/libavfilter/vf_drawtext.c
+++ b/libavfilter/vf_drawtext.c
@@ -1222,9 +1222,7 @@ static int draw_text(AVFilterContext *ctx, AVFrame *frame,
        dummy.code = code;
        glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
        if (!glyph) {
-            ret = load_glyph(ctx, &glyph, code);
-            if (ret < 0)
-                return ret;
+            load_glyph(ctx, &glyph, code);
        }

        y_min = FFMIN(glyph->bbox.yMin, y_min);
--- a/libavformat/cache.c
+++ b/libavformat/cache.c
@@ -283,12 +283,6 @@ resolve_eof:
    return ret;
 }

-static int enu_free(void *opaque, void *elem)
-{
-    av_free(elem);
-    return 0;
-}
-
 static int cache_close(URLContext *h)
 {
    Context *c= h->priv_data;
@@ -298,7 +292,6 @@ static int cache_close(URLContext *h)

    close(c->fd);
    ffurl_close(c->inner);
-    av_tree_enumerate(c->root, NULL, NULL, enu_free);
    av_tree_destroy(c->root);

    return 0;
--- a/libavformat/concatdec.c
+++ b/libavformat/concatdec.c
@@ -710,7 +710,7 @@ static int concat_seek(AVFormatContext *avf, int stream,

 static const AVOption options[] = {
    { "safe", "enable safe mode",
-      OFFSET(safe), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, DEC },
+      OFFSET(safe), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, DEC },
    { "auto_convert", "automatically convert bitstream format",
      OFFSET(auto_convert), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DEC },
    { "segment_time_metadata", "output file segment start time and duration as packet metadata",
--- a/libavformat/ffmdec.c
+++ b/libavformat/ffmdec.c
@@ -775,8 +775,8 @@ static int ffm_probe(AVProbeData *p)

 static const AVOption options[] = {
    {"server_attached", NULL, offsetof(FFMContext, server_attached), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_EXPORT },
-    {"ffm_write_index", NULL, offsetof(FFMContext, write_index), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, AV_OPT_FLAG_EXPORT },
-    {"ffm_file_size", NULL, offsetof(FFMContext, file_size), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, AV_OPT_FLAG_EXPORT },
+    {"ffm_write_index", NULL, offsetof(FFMContext, write_index), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, 1, AV_OPT_FLAG_EXPORT },
+    {"ffm_file_size", NULL, offsetof(FFMContext, file_size), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, 1, AV_OPT_FLAG_EXPORT },
    { NULL },
 };

--- a/libavformat/file.c
+++ b/libavformat/file.c
@@ -349,7 +349,7 @@ URLProtocol ff_file_protocol = {
    .url_open_dir        = file_open_dir,
    .url_read_dir        = file_read_dir,
    .url_close_dir       = file_close_dir,
-    .default_whitelist   = "file,crypto"
+    .default_whitelist   = "file"
 };

 #endif /* CONFIG_FILE_PROTOCOL */
@@ -388,7 +388,7 @@ URLProtocol ff_pipe_protocol = {
    .url_check           = file_check,
    .priv_data_size      = sizeof(FileContext),
    .priv_data_class     = &pipe_class,
-    .default_whitelist   = "crypto"
+    .default_whitelist   = "none"
 };

 #endif /* CONFIG_PIPE_PROTOCOL */
--- a/libavformat/hlsenc.c
+++ b/libavformat/hlsenc.c
@@ -396,7 +396,7 @@ static int hls_window(AVFormatContext *s, int last)

    set_http_options(&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)
+    if ((ret = s->io_open(s, &out, temp_filename, AVIO_FLAG_WRITE, NULL)) < 0)
        goto fail;

    for (en = hls->segments; en; en = en->next) {
--- a/libavformat/http.c
+++ b/libavformat/http.c
@@ -1522,7 +1522,7 @@ URLProtocol ff_http_protocol = {
    .priv_data_size      = sizeof(HTTPContext),
    .priv_data_class     = &http_context_class,
    .flags               = URL_PROTOCOL_FLAG_NETWORK,
-    .default_whitelist   = "http,https,tls,rtp,tcp,udp,crypto,httpproxy"
+    .default_whitelist   = "http,https,tls,rtp,tcp,udp,crypto"
 };
 #endif /* CONFIG_HTTP_PROTOCOL */

@@ -1541,7 +1541,7 @@ URLProtocol ff_https_protocol = {
    .priv_data_size      = sizeof(HTTPContext),
    .priv_data_class     = &https_context_class,
    .flags               = URL_PROTOCOL_FLAG_NETWORK,
-    .default_whitelist   = "http,https,tls,rtp,tcp,udp,crypto,httpproxy"
+    .default_whitelist   = "http,https,tls,rtp,tcp,udp,crypto"
 };
 #endif /* CONFIG_HTTPS_PROTOCOL */

--- a/libavformat/mov.c
+++ b/libavformat/mov.c
@@ -3609,7 +3609,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                }
                av_log(c->fc, AV_LOG_DEBUG, "calculated into dts %"PRId64"\n", dts);
            } else {
-                dts = frag->time - sc->time_offset;
+                dts = frag->time;
                av_log(c->fc, AV_LOG_DEBUG, "found frag time %"PRId64
                        ", using it for dts\n", dts);
            }
@@ -3666,7 +3666,7 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
    version = avio_r8(pb);
    if (version > 1) {
        avpriv_request_sample(c->fc, "sidx version %u", version);
-        return 0;
+        return AVERROR_PATCHWELCOME;
    }

    avio_rb24(pb); // flags
@@ -3679,8 +3679,8 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
        }
    }
    if (!st) {
-        av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %d\n", track_id);
-        return 0;
+        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", track_id);
+        return AVERROR_INVALIDDATA;
    }

    sc = st->priv_data;
--- a/libavformat/mpegtsenc.c
+++ b/libavformat/mpegtsenc.c
@@ -56,7 +56,6 @@ typedef struct MpegTSService {
    int pcr_pid;
    int pcr_packet_count;
    int pcr_packet_period;
-    AVProgram *program;
 } MpegTSService;

 // service_type values as defined in ETSI 300 468
@@ -276,12 +275,15 @@ static int mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
        AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);

        if (s->nb_programs) {
-            int k, found = 0;
-            AVProgram *program = service->program;
+            int j, k, found = 0;

-            for (k = 0; k < program->nb_stream_indexes; k++)
-                if (program->stream_index[k] == i) {
-                    found = 1;
+            for (j = 0; j < s->nb_programs; j++)
+                if (s->programs[j]->id == service->sid) {
+                    for (k = 0; k < s->programs[j]->nb_stream_indexes; k++)
+                        if (s->programs[j]->stream_index[k] == i) {
+                            found = 1;
+                            break;
+                        }
                    break;
                }

@@ -782,7 +784,6 @@ static int mpegts_init(AVFormatContext *s)
            service->pmt.write_packet = section_write_packet;
            service->pmt.opaque       = s;
            service->pmt.cc           = 15;
-            service->program          = program;
        }
    }

@@ -806,7 +807,6 @@ static int mpegts_init(AVFormatContext *s)

    /* assign pids to each stream */
    for (i = 0; i < s->nb_streams; i++) {
-        AVProgram *program;
        st = s->streams[i];

        ts_st = av_mallocz(sizeof(MpegTSWriteStream));
@@ -824,17 +824,6 @@ static int mpegts_init(AVFormatContext *s)
            ret = AVERROR(ENOMEM);
            goto fail;
        }
-
-        program = av_find_program_from_stream(s, NULL, i);
-        if (program) {
-            for (j = 0; j < ts->nb_services; j++) {
-                if (ts->services[j]->program == program) {
-                    service = ts->services[j];
-                    break;
-                }
-            }
-        }
-
        ts_st->service = service;
        /* MPEG pid values < 16 are reserved. Applications which set st->id in
         * this range are assigned a calculated pid. */
--- a/libavformat/mux.c
+++ b/libavformat/mux.c
@@ -400,8 +400,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
    }

    if (s->oformat->init && (ret = s->oformat->init(s)) < 0) {
-        if (s->oformat->deinit)
-            s->oformat->deinit(s);
+        s->oformat->deinit(s);
        goto fail;
    }

--- a/libavformat/rtpdec_jpeg.c
+++ b/libavformat/rtpdec_jpeg.c
@@ -193,17 +193,16 @@ static void create_default_qtables(uint8_t *qtables, uint8_t q)
 {
    int factor = q;
    int i;
-    uint16_t S;

    factor = av_clip(q, 1, 99);

    if (q < 50)
-        S = 5000 / factor;
+        q = 5000 / factor;
    else
-        S = 200 - factor * 2;
+        q = 200 - factor * 2;

    for (i = 0; i < 128; i++) {
-        int val = (default_quantizers[i] * S + 50) / 100;
+        int val = (default_quantizers[i] * q + 50) / 100;

        /* Limit the quantizers to 1 <= q <= 255. */
        val = av_clip(val, 1, 255);
--- a/libavformat/rtpenc.c
+++ b/libavformat/rtpenc.c
@@ -271,8 +271,7 @@ static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
    avio_w8(s1->pb, RTCP_SR);
    avio_wb16(s1->pb, 6); /* length in words - 1 */
    avio_wb32(s1->pb, s->ssrc);
-    avio_wb32(s1->pb, ntp_time / 1000000);
-    avio_wb32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
+    avio_wb64(s1->pb, NTP_TO_RTP_FORMAT(ntp_time));
    avio_wb32(s1->pb, rtp_ts);
    avio_wb32(s1->pb, s->packet_count);
    avio_wb32(s1->pb, s->octet_count);
--- a/libavformat/svag.c
+++ b/libavformat/svag.c
@@ -48,7 +48,7 @@ static int svag_read_header(AVFormatContext *s)
    if (st->codec->sample_rate <= 0)
        return AVERROR_INVALIDDATA;
    st->codec->channels    = avio_rl32(s->pb);
-    if (st->codec->channels <= 0 || st->codec->channels > 8)
+    if (st->codec->channels <= 0)
        return AVERROR_INVALIDDATA;
    st->duration           = size / (16 * st->codec->channels) * 28;
    align                  = avio_rl32(s->pb);
--- a/libavformat/utils.c
+++ b/libavformat/utils.c
@@ -1186,13 +1186,12 @@ static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
        }
    }

-    if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
+    if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
        st->pts_buffer[0] = pkt->pts;
        for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);

-        if(has_decode_delay_been_guessed(st))
-            pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
+        pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
    }
    // We skipped it above so we try here.
    if (!onein_oneout)
--- a/libavutil/channel_layout.c
+++ b/libavutil/channel_layout.c
@@ -94,7 +94,7 @@ static const struct {
    { "6.0(front)",  6,  AV_CH_LAYOUT_6POINT0_FRONT },
    { "hexagonal",   6,  AV_CH_LAYOUT_HEXAGONAL },
    { "6.1",         7,  AV_CH_LAYOUT_6POINT1 },
-    { "6.1(back)",   7,  AV_CH_LAYOUT_6POINT1_BACK },
+    { "6.1",         7,  AV_CH_LAYOUT_6POINT1_BACK },
    { "6.1(front)",  7,  AV_CH_LAYOUT_6POINT1_FRONT },
    { "7.0",         7,  AV_CH_LAYOUT_7POINT0 },
    { "7.0(front)",  7,  AV_CH_LAYOUT_7POINT0_FRONT },
--- a/libavutil/colorspace.h
+++ b/libavutil/colorspace.h
@@ -41,16 +41,6 @@
    b_add = FIX(1.77200*255.0/224.0) * cb + ONE_HALF;\
 }

-#define YUV_TO_RGB1_CCIR_BT709(cb1, cr1)\
-{\
-    cb = (cb1) - 128;\
-    cr = (cr1) - 128;\
-    r_add = FIX(1.5747*255.0/224.0) * cr + ONE_HALF;\
-    g_add = - FIX(0.1873*255.0/224.0) * cb - FIX(0.4682*255.0/224.0) * cr + \
-            ONE_HALF;\
-    b_add = FIX(1.8556*255.0/224.0) * cb + ONE_HALF;\
-}
-
 #define YUV_TO_RGB2_CCIR(r, g, b, y1)\
 {\
    y = ((y1) - 16) * FIX(255.0/219.0);\
--- a/libavutil/cpu_internal.h
+++ b/libavutil/cpu_internal.h
@@ -24,16 +24,13 @@
 #define CPUEXT_SUFFIX(flags, suffix, cpuext)                            \
    (HAVE_ ## cpuext ## suffix && ((flags) & AV_CPU_FLAG_ ## cpuext))

-#define CPUEXT_SUFFIX_FAST2(flags, suffix, cpuext, slow_cpuext)         \
+#define CPUEXT_SUFFIX_FAST(flags, suffix, cpuext)                       \
    (HAVE_ ## cpuext ## suffix && ((flags) & AV_CPU_FLAG_ ## cpuext) && \
-     !((flags) & AV_CPU_FLAG_ ## slow_cpuext ## SLOW))
+     !((flags) & AV_CPU_FLAG_ ## cpuext ## SLOW))

-#define CPUEXT_SUFFIX_SLOW2(flags, suffix, cpuext, slow_cpuext)         \
+#define CPUEXT_SUFFIX_SLOW(flags, suffix, cpuext)                       \
    (HAVE_ ## cpuext ## suffix && ((flags) & AV_CPU_FLAG_ ## cpuext) && \
-     ((flags) & AV_CPU_FLAG_ ## slow_cpuext ## SLOW))
-
-#define CPUEXT_SUFFIX_FAST(flags, suffix, cpuext) CPUEXT_SUFFIX_FAST2(flags, suffix, cpuext, cpuext)
-#define CPUEXT_SUFFIX_SLOW(flags, suffix, cpuext) CPUEXT_SUFFIX_SLOW2(flags, suffix, cpuext, cpuext)
+     ((flags) & AV_CPU_FLAG_ ## cpuext ## SLOW))

 #define CPUEXT(flags, cpuext) CPUEXT_SUFFIX(flags, , cpuext)
 #define CPUEXT_FAST(flags, cpuext) CPUEXT_SUFFIX_FAST(flags, , cpuext)
--- a/libavutil/internal.h
+++ b/libavutil/internal.h
@@ -313,22 +313,6 @@ static av_always_inline float ff_exp10f(float x)
    return exp2f(M_LOG2_10 * x);
 }

-/**
- * Compute x^y for floating point x, y. Note: this function is faster than the
- * libm variant due to mainly 2 reasons:
- * 1. It does not handle any edge cases. In particular, this is only guaranteed
- * to work correctly for x > 0.
- * 2. It is not as accurate as a standard nearly "correctly rounded" libm variant.
- * @param x base
- * @param y exponent
- * @return x^y
- */
-static av_always_inline float ff_fast_powf(float x, float y)
-{
-    return expf(logf(x) * y);
-}
-
-
 /**
 * A wrapper for open() setting O_CLOEXEC.
 */
--- a/libavutil/mips/float_dsp_mips.c
+++ b/libavutil/mips/float_dsp_mips.c
@@ -56,7 +56,6 @@
 #include "libavutil/mips/asmdefs.h"

 #if HAVE_INLINE_ASM && HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 static void vector_fmul_mips(float *dst, const float *src0, const float *src1,
                             int len)
 {
@@ -340,17 +339,14 @@ static void vector_fmul_reverse_mips(float *dst, const float *src0, const float
        );
    }
 }
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM && HAVE_MIPSFPU */

 void ff_float_dsp_init_mips(AVFloatDSPContext *fdsp) {
 #if HAVE_INLINE_ASM && HAVE_MIPSFPU
-#if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
    fdsp->vector_fmul = vector_fmul_mips;
    fdsp->vector_fmul_scalar  = vector_fmul_scalar_mips;
    fdsp->vector_fmul_window = vector_fmul_window_mips;
    fdsp->butterflies_float = butterflies_float_mips;
    fdsp->vector_fmul_reverse = vector_fmul_reverse_mips;
-#endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM && HAVE_MIPSFPU */
 }
--- a/libavutil/pixdesc.c
+++ b/libavutil/pixdesc.c
@@ -2275,7 +2275,6 @@ enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
 #define FF_COLOR_GRAY     1 /**< gray color space */
 #define FF_COLOR_YUV      2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
 #define FF_COLOR_YUV_JPEG 3 /**< YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
-#define FF_COLOR_XYZ      4

 #define pixdesc_has_alpha(pixdesc) \
    ((pixdesc)->nb_components == 2 || (pixdesc)->nb_components == 4 || (pixdesc)->flags & AV_PIX_FMT_FLAG_PAL)
@@ -2291,9 +2290,6 @@ static int get_color_type(const AVPixFmtDescriptor *desc) {
    if(desc->name && !strncmp(desc->name, "yuvj", 4))
        return FF_COLOR_YUV_JPEG;

-    if(desc->name && !strncmp(desc->name, "xyz", 3))
-        return FF_COLOR_XYZ;
-
    if(desc->flags & AV_PIX_FMT_FLAG_RGB)
        return  FF_COLOR_RGB;

--- a/libavutil/random_seed.c
+++ b/libavutil/random_seed.c
@@ -97,13 +97,8 @@ static uint32_t get_generic_seed(void)
        last_t = t;
    }

-    if(TEST) {
+    if(TEST)
        buffer[0] = buffer[1] = 0;
-    } else {
-#ifdef AV_READ_TIME
-        buffer[111] += AV_READ_TIME();
-#endif
-    }

    av_sha_init(sha, 160);
    av_sha_update(sha, (const uint8_t *)buffer, sizeof(buffer));
--- a/libavutil/x86/cpu.h
+++ b/libavutil/x86/cpu.h
@@ -68,12 +68,8 @@
 #define EXTERNAL_AVX_SLOW(flags)    CPUEXT_SUFFIX_SLOW(flags, _EXTERNAL, AVX)
 #define EXTERNAL_XOP(flags)         CPUEXT_SUFFIX(flags, _EXTERNAL, XOP)
 #define EXTERNAL_FMA3(flags)        CPUEXT_SUFFIX(flags, _EXTERNAL, FMA3)
-#define EXTERNAL_FMA3_FAST(flags)   CPUEXT_SUFFIX_FAST2(flags, _EXTERNAL, FMA3, AVX)
-#define EXTERNAL_FMA3_SLOW(flags)   CPUEXT_SUFFIX_SLOW2(flags, _EXTERNAL, FMA3, AVX)
 #define EXTERNAL_FMA4(flags)        CPUEXT_SUFFIX(flags, _EXTERNAL, FMA4)
 #define EXTERNAL_AVX2(flags)        CPUEXT_SUFFIX(flags, _EXTERNAL, AVX2)
-#define EXTERNAL_AVX2_FAST(flags)   CPUEXT_SUFFIX_FAST2(flags, _EXTERNAL, AVX2, AVX)
-#define EXTERNAL_AVX2_SLOW(flags)   CPUEXT_SUFFIX_SLOW2(flags, _EXTERNAL, AVX2, AVX)
 #define EXTERNAL_AESNI(flags)       CPUEXT_SUFFIX(flags, _EXTERNAL, AESNI)

 #define INLINE_AMD3DNOW(flags)      CPUEXT_SUFFIX(flags, _INLINE, AMD3DNOW)
--- a/libavutil/x86/float_dsp_init.c
+++ b/libavutil/x86/float_dsp_init.c
@@ -92,7 +92,7 @@ av_cold void ff_float_dsp_init_x86(AVFloatDSPContext *fdsp)
        fdsp->vector_fmul_add    = ff_vector_fmul_add_avx;
        fdsp->vector_fmul_reverse = ff_vector_fmul_reverse_avx;
    }
-    if (EXTERNAL_FMA3_FAST(cpu_flags)) {
+    if (EXTERNAL_FMA3(cpu_flags) && !(cpu_flags & AV_CPU_FLAG_AVXSLOW)) {
        fdsp->vector_fmac_scalar = ff_vector_fmac_scalar_fma3;
        fdsp->vector_fmul_add    = ff_vector_fmul_add_fma3;
    }
--- a/libavutil/x86/lls_init.c
+++ b/libavutil/x86/lls_init.c
@@ -39,7 +39,7 @@ av_cold void ff_init_lls_x86(LLSModel *m)
    if (EXTERNAL_AVX_FAST(cpu_flags)) {
        m->update_lls = ff_update_lls_avx;
    }
-    if (EXTERNAL_FMA3_FAST(cpu_flags)) {
+    if (EXTERNAL_FMA3(cpu_flags) && !(cpu_flags & AV_CPU_FLAG_AVXSLOW)) {
        m->update_lls = ff_update_lls_fma3;
    }
 }
--- a/libpostproc/postprocess.c
+++ b/libpostproc/postprocess.c
@@ -973,7 +973,7 @@ void  pp_postprocess(const uint8_t * src[3], const int srcStride[3],
        int i;
        const int count= FFMAX(mbHeight * absQPStride, mbWidth);
        for(i=0; i<(count>>2); i++){
-            AV_WN32(c->stdQPTable + (i<<2), AV_RN32(QP_store + (i<<2)) >> 1 & 0x7F7F7F7F);
+            ((uint32_t*)c->stdQPTable)[i] = (((const uint32_t*)QP_store)[i]>>1) & 0x7F7F7F7F;
        }
        for(i<<=2; i<count; i++){
            c->stdQPTable[i] = QP_store[i]>>1;
--- a/libswresample/x86/audio_convert_init.c
+++ b/libswresample/x86/audio_convert_init.c
@@ -174,7 +174,7 @@ MULTI_CAPS_FUNC(SSE2, sse2)
                ac->simd_f =  ff_pack_8ch_float_to_int32_a_avx;
        }
    }
-    if(EXTERNAL_AVX2_FAST(mm_flags)) {
+    if(EXTERNAL_AVX2(mm_flags)) {
        if(   out_fmt == AV_SAMPLE_FMT_S32  && in_fmt == AV_SAMPLE_FMT_FLT || out_fmt == AV_SAMPLE_FMT_S32P && in_fmt == AV_SAMPLE_FMT_FLTP)
            ac->simd_f =  ff_float_to_int32_a_avx2;
    }
--- a/libswresample/x86/resample_init.c
+++ b/libswresample/x86/resample_init.c
@@ -71,7 +71,7 @@ av_cold void swri_resample_dsp_x86_init(ResampleContext *c)
            c->dsp.resample = c->linear ? ff_resample_linear_float_avx
                                        : ff_resample_common_float_avx;
        }
-        if (EXTERNAL_FMA3_FAST(mm_flags)) {
+        if (EXTERNAL_FMA3(mm_flags) && !(mm_flags & AV_CPU_FLAG_AVXSLOW)) {
            c->dsp.resample = c->linear ? ff_resample_linear_float_fma3
                                        : ff_resample_common_float_fma3;
        }
--- a/libswscale/input.c
+++ b/libswscale/input.c
@@ -885,19 +885,6 @@ static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_sr
    }
 }

-static av_always_inline void planar_rgb16_to_a(uint8_t *_dst, const uint8_t *_src[4],
-                                               int width, int bpc, int is_be, int32_t *rgb2yuv)
-{
-    int i;
-    const uint16_t **src = (const uint16_t **)_src;
-    uint16_t *dst        = (uint16_t *)_dst;
-    int shift = bpc < 16 ? bpc : 14;
-
-    for (i = 0; i < width; i++) {
-        dst[i] = rdpx(src[3] + i) << (14 - shift);
-    }
-}
-
 static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
                                                const uint8_t *_src[4], int width,
                                                int bpc, int is_be, int32_t *rgb2yuv)
@@ -926,11 +913,6 @@ 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)  \
 {                                                                                                   \
@@ -1266,7 +1248,6 @@ av_cold void ff_sws_init_input_funcs(SwsContext *c)
        c->readLumPlanar = planar_rgb14le_to_y;
        break;
    case AV_PIX_FMT_GBRAP16LE:
-        c->readAlpPlanar = planar_rgb16le_to_a;
    case AV_PIX_FMT_GBRP16LE:
        c->readLumPlanar = planar_rgb16le_to_y;
        break;
@@ -1283,7 +1264,6 @@ av_cold void ff_sws_init_input_funcs(SwsContext *c)
        c->readLumPlanar = planar_rgb14be_to_y;
        break;
    case AV_PIX_FMT_GBRAP16BE:
-        c->readAlpPlanar = planar_rgb16be_to_a;
    case AV_PIX_FMT_GBRP16BE:
        c->readLumPlanar = planar_rgb16be_to_y;
        break;
--- a/libswscale/utils.c
+++ b/libswscale/utils.c
@@ -1354,7 +1354,6 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
        srcFormat != AV_PIX_FMT_GBRP12BE  && srcFormat != AV_PIX_FMT_GBRP12LE &&
        srcFormat != AV_PIX_FMT_GBRP14BE  && srcFormat != AV_PIX_FMT_GBRP14LE &&
        srcFormat != AV_PIX_FMT_GBRP16BE  && srcFormat != AV_PIX_FMT_GBRP16LE &&
-        srcFormat != AV_PIX_FMT_GBRAP16BE  && srcFormat != AV_PIX_FMT_GBRAP16LE &&
        ((dstW >> c->chrDstHSubSample) <= (srcW >> 1) ||
         (flags & SWS_FAST_BILINEAR)))
        c->chrSrcHSubSample = 1;
--- a/libswscale/x86/output.asm
+++ b/libswscale/x86/output.asm
@@ -54,118 +54,6 @@ SECTION .text
 ; int32_t if $output_size is 16. $filter is 12-bits. $filterSize is a multiple
 ; of 2. $offset is either 0 or 3. $dither holds 8 values.
 ;-----------------------------------------------------------------------------
-%macro yuv2planeX_mainloop 2
-.pixelloop_%2:
-%assign %%i 0
-    ; the rep here is for the 8bit output mmx case, where dither covers
-    ; 8 pixels but we can only handle 2 pixels per register, and thus 4
-    ; pixels per iteration. In order to not have to keep track of where
-    ; we are w.r.t. dithering, we unroll the mmx/8bit loop x2.
-%if %1 == 8
-%assign %%repcnt 16/mmsize
-%else
-%assign %%repcnt 1
-%endif
-
-%rep %%repcnt
-
-%if %1 == 8
-%if ARCH_X86_32
-    mova            m2, [rsp+mmsize*(0+%%i)]
-    mova            m1, [rsp+mmsize*(1+%%i)]
-%else ; x86-64
-    mova            m2,  m8
-    mova            m1,  m_dith
-%endif ; x86-32/64
-%else ; %1 == 9/10/16
-    mova            m1, [yuv2yuvX_%1_start]
-    mova            m2,  m1
-%endif ; %1 == 8/9/10/16
-    movsx     cntr_reg,  fltsizem
-.filterloop_%2_ %+ %%i:
-    ; input pixels
-    mov             r6, [srcq+gprsize*cntr_reg-2*gprsize]
-%if %1 == 16
-    mova            m3, [r6+r5*4]
-    mova            m5, [r6+r5*4+mmsize]
-%else ; %1 == 8/9/10
-    mova            m3, [r6+r5*2]
-%endif ; %1 == 8/9/10/16
-    mov             r6, [srcq+gprsize*cntr_reg-gprsize]
-%if %1 == 16
-    mova            m4, [r6+r5*4]
-    mova            m6, [r6+r5*4+mmsize]
-%else ; %1 == 8/9/10
-    mova            m4, [r6+r5*2]
-%endif ; %1 == 8/9/10/16
-
-    ; coefficients
-    movd            m0, [filterq+2*cntr_reg-4] ; coeff[0], coeff[1]
-%if %1 == 16
-    pshuflw         m7,  m0,  0          ; coeff[0]
-    pshuflw         m0,  m0,  0x55       ; coeff[1]
-    pmovsxwd        m7,  m7              ; word -> dword
-    pmovsxwd        m0,  m0              ; word -> dword
-
-    pmulld          m3,  m7
-    pmulld          m5,  m7
-    pmulld          m4,  m0
-    pmulld          m6,  m0
-
-    paddd           m2,  m3
-    paddd           m1,  m5
-    paddd           m2,  m4
-    paddd           m1,  m6
-%else ; %1 == 10/9/8
-    punpcklwd       m5,  m3,  m4
-    punpckhwd       m3,  m4
-    SPLATD          m0
-
-    pmaddwd         m5,  m0
-    pmaddwd         m3,  m0
-
-    paddd           m2,  m5
-    paddd           m1,  m3
-%endif ; %1 == 8/9/10/16
-
-    sub       cntr_reg,  2
-    jg .filterloop_%2_ %+ %%i
-
-%if %1 == 16
-    psrad           m2,  31 - %1
-    psrad           m1,  31 - %1
-%else ; %1 == 10/9/8
-    psrad           m2,  27 - %1
-    psrad           m1,  27 - %1
-%endif ; %1 == 8/9/10/16
-
-%if %1 == 8
-    packssdw        m2,  m1
-    packuswb        m2,  m2
-    movh   [dstq+r5*1],  m2
-%else ; %1 == 9/10/16
-%if %1 == 16
-    packssdw        m2,  m1
-    paddw           m2, [minshort]
-%else ; %1 == 9/10
-%if cpuflag(sse4)
-    packusdw        m2,  m1
-%else ; mmxext/sse2
-    packssdw        m2,  m1
-    pmaxsw          m2,  m6
-%endif ; mmxext/sse2/sse4/avx
-    pminsw          m2, [yuv2yuvX_%1_upper]
-%endif ; %1 == 9/10/16
-    mov%2   [dstq+r5*2],  m2
-%endif ; %1 == 8/9/10/16
-
-    add             r5,  mmsize/2
-    sub             wd,  mmsize/2
-
-%assign %%i %%i+2
-%endrep
-    jg .pixelloop_%2
-%endmacro

 %macro yuv2planeX_fn 3

@@ -235,16 +123,116 @@ cglobal yuv2planeX_%1, %3, 8, %2, filter, fltsize, src, dst, w, dither, offset

    xor             r5,  r5

-%if mmsize == 8 || %1 == 8
-    yuv2planeX_mainloop %1, a
-%else ; mmsize == 16
-    test          dstq, 15
-    jnz .unaligned
-    yuv2planeX_mainloop %1, a
-    REP_RET
-.unaligned:
-    yuv2planeX_mainloop %1, u
-%endif ; mmsize == 8/16
+.pixelloop:
+%assign %%i 0
+    ; the rep here is for the 8bit output mmx case, where dither covers
+    ; 8 pixels but we can only handle 2 pixels per register, and thus 4
+    ; pixels per iteration. In order to not have to keep track of where
+    ; we are w.r.t. dithering, we unroll the mmx/8bit loop x2.
+%if %1 == 8
+%assign %%repcnt 16/mmsize
+%else
+%assign %%repcnt 1
+%endif
+
+%rep %%repcnt
+
+%if %1 == 8
+%if ARCH_X86_32
+    mova            m2, [rsp+mmsize*(0+%%i)]
+    mova            m1, [rsp+mmsize*(1+%%i)]
+%else ; x86-64
+    mova            m2,  m8
+    mova            m1,  m_dith
+%endif ; x86-32/64
+%else ; %1 == 9/10/16
+    mova            m1, [yuv2yuvX_%1_start]
+    mova            m2,  m1
+%endif ; %1 == 8/9/10/16
+    movsx     cntr_reg,  fltsizem
+.filterloop_ %+ %%i:
+    ; input pixels
+    mov             r6, [srcq+gprsize*cntr_reg-2*gprsize]
+%if %1 == 16
+    mova            m3, [r6+r5*4]
+    mova            m5, [r6+r5*4+mmsize]
+%else ; %1 == 8/9/10
+    mova            m3, [r6+r5*2]
+%endif ; %1 == 8/9/10/16
+    mov             r6, [srcq+gprsize*cntr_reg-gprsize]
+%if %1 == 16
+    mova            m4, [r6+r5*4]
+    mova            m6, [r6+r5*4+mmsize]
+%else ; %1 == 8/9/10
+    mova            m4, [r6+r5*2]
+%endif ; %1 == 8/9/10/16
+
+    ; coefficients
+    movd            m0, [filterq+2*cntr_reg-4] ; coeff[0], coeff[1]
+%if %1 == 16
+    pshuflw         m7,  m0,  0          ; coeff[0]
+    pshuflw         m0,  m0,  0x55       ; coeff[1]
+    pmovsxwd        m7,  m7              ; word -> dword
+    pmovsxwd        m0,  m0              ; word -> dword
+
+    pmulld          m3,  m7
+    pmulld          m5,  m7
+    pmulld          m4,  m0
+    pmulld          m6,  m0
+
+    paddd           m2,  m3
+    paddd           m1,  m5
+    paddd           m2,  m4
+    paddd           m1,  m6
+%else ; %1 == 10/9/8
+    punpcklwd       m5,  m3,  m4
+    punpckhwd       m3,  m4
+    SPLATD          m0
+
+    pmaddwd         m5,  m0
+    pmaddwd         m3,  m0
+
+    paddd           m2,  m5
+    paddd           m1,  m3
+%endif ; %1 == 8/9/10/16
+
+    sub       cntr_reg,  2
+    jg .filterloop_ %+ %%i
+
+%if %1 == 16
+    psrad           m2,  31 - %1
+    psrad           m1,  31 - %1
+%else ; %1 == 10/9/8
+    psrad           m2,  27 - %1
+    psrad           m1,  27 - %1
+%endif ; %1 == 8/9/10/16
+
+%if %1 == 8
+    packssdw        m2,  m1
+    packuswb        m2,  m2
+    movh   [dstq+r5*1],  m2
+%else ; %1 == 9/10/16
+%if %1 == 16
+    packssdw        m2,  m1
+    paddw           m2, [minshort]
+%else ; %1 == 9/10
+%if cpuflag(sse4)
+    packusdw        m2,  m1
+%else ; mmxext/sse2
+    packssdw        m2,  m1
+    pmaxsw          m2,  m6
+%endif ; mmxext/sse2/sse4/avx
+    pminsw          m2, [yuv2yuvX_%1_upper]
+%endif ; %1 == 9/10/16
+    mova   [dstq+r5*2],  m2
+%endif ; %1 == 8/9/10/16
+
+    add             r5,  mmsize/2
+    sub             wd,  mmsize/2
+
+%assign %%i %%i+2
+%endrep
+    jg .pixelloop

 %if %1 == 8
 %if ARCH_X86_32
--- a/tests/fate/aac.mak
+++ b/tests/fate/aac.mak
@@ -175,7 +175,7 @@ fate-aac-pns-encode: REF = $(SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.w
 fate-aac-pns-encode: CMP_SHIFT = -4096
 fate-aac-pns-encode: CMP_TARGET = 616
 fate-aac-pns-encode: SIZE_TOLERANCE = 3560
-fate-aac-pns-encode: FUZZ = 74
+fate-aac-pns-encode: FUZZ = 72

 FATE_AAC_ENCODE += fate-aac-tns-encode
 fate-aac-tns-encode: CMD = enc_dec_pcm adts wav s16le $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav -c:a aac -aac_tns 1 -aac_is 0 -aac_pns 0 -aac_ms 0 -b:a 128k -cutoff 22050  -fflags +bitexact -flags +bitexact
--- a/tests/fate/source-check.sh
+++ b/tests/fate/source-check.sh
@@ -2,7 +2,7 @@

 cd "$1"/..

-git show > /dev/null 2> /dev/null || { cat tests/ref/fate/source ; exit 0; }
+git --version > /dev/null || { cat tests/ref/fate/source ; exit 0; }

 echo Files without standard license headers:
 git grep -L -E "This file is part of FFmpeg|This file is part of libswresample|"\
--- a/tests/ref/fate/mkv
+++ b/tests/ref/fate/mkv
@@ -25,9 +25,9 @@
 1,        264,        264,       21,      609, 0xc0dc255c
 1,        285,        285,       21,      619, 0x9ac52dd1
 0,        292,        292,       41,    16751, 0xf293ab46, F=0x0
+0,        292,        417,       41,    22029, 0x3696462b, F=0x0
 1,        306,        306,       21,      574, 0xf6410d4d
 1,        327,        327,       22,      565, 0xfd561191
-0,        334,        417,       41,    22029, 0x3696462b, F=0x0
 1,        350,        350,       21,      713, 0x48425147
 1,        371,        371,       21,      537, 0x09bbf515
 0,        375,        375,       41,     5044, 0xa0344ae6, F=0x0
@@ -1 +1 @@
 .0.2
 .8.git