Merge remote-tracking branch 'qatar/master'

* qatar/master: (28 commits)
  Replace usages of av_get_bits_per_sample_fmt() with av_get_bytes_per_sample().
  x86: cabac: fix register constraints for 32-bit mode
  cabac: move x86 asm to libavcodec/x86/cabac.h
  x86: h264: cast pointers to intptr_t rather than int
  x86: h264: remove hardcoded edi in decode_significance_8x8_x86()
  x86: h264: remove hardcoded esi in decode_significance[_8x8]_x86()
  x86: h264: remove hardcoded edx in decode_significance[_8x8]_x86()
  x86: h264: remove hardcoded eax in decode_significance[_8x8]_x86()
  x86: cabac: change 'a' constraint to 'r' in get_cabac_inline()
  x86: cabac: remove hardcoded esi in get_cabac_inline()
  x86: cabac: remove hardcoded edx in get_cabac_inline()
  x86: cabac: remove unused macro parameter
  x86: cabac: remove hardcoded ebx in inline asm
  x86: cabac: remove hardcoded struct offsets from inline asm
  cabac: remove inline asm under #if 0
  cabac: remove BRANCHLESS_CABAC_DECODER switch
  cabac: remove #if 0 cascade under never-set #ifdef ARCH_X86_DISABLED
  document libswscale bump
  error_resilience: skip last-MV predictor step if MVs are not available.
  error_resilience: actually add counter when adding a MV predictor.
  ...

Conflicts:
	Changelog
	libavcodec/error_resilience.c
	libavfilter/defaults.c
	libavfilter/vf_drawtext.c
	libswscale/swscale.h
	tests/ref/vsynth1/error
	tests/ref/vsynth2/error
Merged-by: Michael Niedermayer <michaelni@gmx.at>

Changelog

@@ -18,6 +18,7 @@ version 0.7:
 - 10-bit H.264 optimizations for x86
 - lut, lutrgb, and lutyuv filters added
 - buffersink libavfilter sink added
+- Bump libswscale for recently reported ABI break
 
 
 version 0.7_beta2:

doc/APIchanges

@@ -7,7 +7,7 @@ libavdevice: 2011-04-18
 libavfilter: 2011-04-18
 libavformat: 2011-04-18
 libpostproc: 2011-04-18
-libswscale:  2011-04-18
+libswscale:  2011-06-20
 libavutil:   2011-04-18
 
 

ffmpeg.c

@@ -810,8 +810,8 @@ static void do_audio_out(AVFormatContext *s,
     int size_out, frame_bytes, ret, resample_changed;
     AVCodecContext *enc= ost->st->codec;
     AVCodecContext *dec= ist->st->codec;
-    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
-    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
+    int osize = av_get_bytes_per_sample(enc->sample_fmt);
+    int isize = av_get_bytes_per_sample(dec->sample_fmt);
     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
 
 need_realloc:
@@ -1531,7 +1531,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
 #endif
 
     AVPacket avpkt;
-    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
+    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
 
     if(ist->next_pts == AV_NOPTS_VALUE)
         ist->next_pts= ist->pts;

ffplay.c

@@ -2010,7 +2010,7 @@ static int audio_decode_frame(VideoState *is, double *pts_ptr)
             if (is->reformat_ctx) {
                 const void *ibuf[6]= {is->audio_buf1};
                 void *obuf[6]= {is->audio_buf2};
-                int istride[6]= {av_get_bits_per_sample_fmt(dec->sample_fmt)/8};
+                int istride[6]= {av_get_bytes_per_sample(dec->sample_fmt)};
                 int ostride[6]= {2};
                 int len= data_size/istride[0];
                 if (av_audio_convert(is->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {

libavcodec/aacdec.c

@@ -2179,7 +2179,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
     }
 
     data_size_tmp = samples * avctx->channels *
-                    (av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8);
+                    av_get_bytes_per_sample(avctx->sample_fmt);
     if (*data_size < data_size_tmp) {
         av_log(avctx, AV_LOG_ERROR,
                "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",

libavcodec/ac3dec.c

@@ -1422,7 +1422,7 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
         }
     }
     *data_size = s->num_blocks * 256 * avctx->channels *
-                 (av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8);
+                 av_get_bytes_per_sample(avctx->sample_fmt);
     return FFMIN(buf_size, s->frame_size);
 }
 

libavcodec/alsdec.c

@@ -1450,7 +1450,7 @@ static int decode_frame(AVCodecContext *avctx,
 
     // check for size of decoded data
     size = ctx->cur_frame_length * avctx->channels *
-           (av_get_bits_per_sample_fmt(avctx->sample_fmt) >> 3);
+           av_get_bytes_per_sample(avctx->sample_fmt);
 
     if (size > *data_size) {
         av_log(avctx, AV_LOG_ERROR, "Decoded data exceeds buffer size.\n");
@@ -1714,7 +1714,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
         ctx->crc_buffer = av_malloc(sizeof(*ctx->crc_buffer) *
                                     ctx->cur_frame_length *
                                     avctx->channels *
-                                    (av_get_bits_per_sample_fmt(avctx->sample_fmt) >> 3));
+                                    av_get_bytes_per_sample(avctx->sample_fmt));
         if (!ctx->crc_buffer) {
             av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
             decode_end(avctx);

libavcodec/cabac.c

@@ -161,19 +161,11 @@ void ff_init_cabac_states(CABACContext *c){
         ff_h264_mps_state[2*i+1]= 2*mps_state[i]+1;
 
         if( i ){
-#ifdef BRANCHLESS_CABAC_DECODER
             ff_h264_mlps_state[128-2*i-1]= 2*lps_state[i]+0;
             ff_h264_mlps_state[128-2*i-2]= 2*lps_state[i]+1;
         }else{
             ff_h264_mlps_state[128-2*i-1]= 1;
             ff_h264_mlps_state[128-2*i-2]= 0;
-#else
-            ff_h264_lps_state[2*i+0]= 2*lps_state[i]+0;
-            ff_h264_lps_state[2*i+1]= 2*lps_state[i]+1;
-        }else{
-            ff_h264_lps_state[2*i+0]= 1;
-            ff_h264_lps_state[2*i+1]= 0;
-#endif
         }
     }
 }

libavcodec/dca.c

@@ -1817,7 +1817,7 @@ static int dca_decode_frame(AVCodecContext * avctx,
     }
 
     out_size = 256 / 8 * s->sample_blocks * channels *
-               (av_get_bits_per_sample_fmt(avctx->sample_fmt) / 8);
+               av_get_bytes_per_sample(avctx->sample_fmt);
     if (*data_size < out_size)
         return -1;
     *data_size = out_size;

libavcodec/error_resilience.c

@@ -542,6 +542,9 @@ skip_mean_and_median:
                             ff_thread_await_progress((AVFrame *) s->last_picture_ptr,
                                                      mb_y, 0);
                         }
+                        if (!s->last_picture.motion_val[0] ||
+                            !s->last_picture.ref_index[0])
+                            goto skip_last_mv;
                         prev_x = s->last_picture.motion_val[0][mot_index][0];
                         prev_y = s->last_picture.motion_val[0][mot_index][1];
                         prev_ref = s->last_picture.ref_index[0][4*mb_xy];
@@ -556,6 +559,7 @@ skip_mean_and_median:
                     mv_predictor[pred_count][1]= prev_y;
                     ref         [pred_count]   = prev_ref;
                     pred_count++;
+                skip_last_mv:
 
                     s->mv_dir = MV_DIR_FORWARD;
                     s->mb_intra=0;

libavcodec/h264.c

@@ -3690,6 +3690,8 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
             switch (hx->nal_unit_type) {
                 case NAL_SPS:
                 case NAL_PPS:
+                case NAL_IDR_SLICE:
+                case NAL_SLICE:
                     nals_needed = nal_index;
             }
             continue;

libavcodec/resample.c

@@ -239,8 +239,8 @@ ReSampleContext *av_audio_resample_init(int output_channels, int input_channels,
 
     s->sample_fmt[0]  = sample_fmt_in;
     s->sample_fmt[1]  = sample_fmt_out;
-    s->sample_size[0] = av_get_bits_per_sample_fmt(s->sample_fmt[0]) >> 3;
-    s->sample_size[1] = av_get_bits_per_sample_fmt(s->sample_fmt[1]) >> 3;
+    s->sample_size[0] = av_get_bytes_per_sample(s->sample_fmt[0]);
+    s->sample_size[1] = av_get_bytes_per_sample(s->sample_fmt[1]);
 
     if (s->sample_fmt[0] != AV_SAMPLE_FMT_S16) {
         if (!(s->convert_ctx[0] = av_audio_convert_alloc(AV_SAMPLE_FMT_S16, 1,

libavcodec/utils.c

@@ -1210,7 +1210,7 @@ int av_get_bits_per_sample(enum CodecID codec_id){
 
 #if FF_API_OLD_SAMPLE_FMT
 int av_get_bits_per_sample_format(enum AVSampleFormat sample_fmt) {
-    return av_get_bits_per_sample_fmt(sample_fmt);
+    return av_get_bytes_per_sample(sample_fmt) << 3;
 }
 #endif
 

libavcodec/vmdav.c

@@ -450,7 +450,7 @@ static av_cold int vmdaudio_decode_init(AVCodecContext *avctx)
         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
     else
         avctx->sample_fmt = AV_SAMPLE_FMT_U8;
-    s->out_bps = av_get_bits_per_sample_fmt(avctx->sample_fmt) >> 3;
+    s->out_bps = av_get_bytes_per_sample(avctx->sample_fmt);
 
     av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
            "block align = %d, sample rate = %d\n",

libavcodec/vorbisdec.c

@@ -1646,7 +1646,7 @@ static int vorbis_decode_frame(AVCodecContext *avccontext,
                                                vc->audio_channels);
 
     *data_size = len * vc->audio_channels *
-                 (av_get_bits_per_sample_fmt(avccontext->sample_fmt) / 8);
+                 av_get_bytes_per_sample(avccontext->sample_fmt);
 
     return buf_size ;
 }

libavcodec/x86/cabac.h

+/*
+ * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_X86_CABAC_H
+#define AVCODEC_X86_CABAC_H
+
+#include "libavcodec/cabac.h"
+#include "libavutil/attributes.h"
+#include "libavutil/x86_cpu.h"
+#include "config.h"
+
+#if HAVE_FAST_CMOV
+#define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp)\
+        "mov    "tmp"       , %%ecx     \n\t"\
+        "shl    $17         , "tmp"     \n\t"\
+        "cmp    "low"       , "tmp"     \n\t"\
+        "cmova  %%ecx       , "range"   \n\t"\
+        "sbb    %%ecx       , %%ecx     \n\t"\
+        "and    %%ecx       , "tmp"     \n\t"\
+        "sub    "tmp"       , "low"     \n\t"\
+        "xor    %%ecx       , "ret"     \n\t"
+#else /* HAVE_FAST_CMOV */
+#define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp)\
+        "mov    "tmp"       , %%ecx     \n\t"\
+        "shl    $17         , "tmp"     \n\t"\
+        "sub    "low"       , "tmp"     \n\t"\
+        "sar    $31         , "tmp"     \n\t" /*lps_mask*/\
+        "sub    %%ecx       , "range"   \n\t" /*RangeLPS - range*/\
+        "and    "tmp"       , "range"   \n\t" /*(RangeLPS - range)&lps_mask*/\
+        "add    %%ecx       , "range"   \n\t" /*new range*/\
+        "shl    $17         , %%ecx     \n\t"\
+        "and    "tmp"       , %%ecx     \n\t"\
+        "sub    %%ecx       , "low"     \n\t"\
+        "xor    "tmp"       , "ret"     \n\t"
+#endif /* HAVE_FAST_CMOV */
+
+#define BRANCHLESS_GET_CABAC(ret, cabac, statep, low, lowword, range, tmp, tmpbyte, byte) \
+        "movzbl "statep"    , "ret"                                     \n\t"\
+        "mov    "range"     , "tmp"                                     \n\t"\
+        "and    $0xC0       , "range"                                   \n\t"\
+        "movzbl "MANGLE(ff_h264_lps_range)"("ret", "range", 2), "range" \n\t"\
+        "sub    "range"     , "tmp"                                     \n\t"\
+        BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword,        \
+                                    range, tmp)                              \
+        "movzbl " MANGLE(ff_h264_norm_shift) "("range"), %%ecx          \n\t"\
+        "shl    %%cl        , "range"                                   \n\t"\
+        "movzbl "MANGLE(ff_h264_mlps_state)"+128("ret"), "tmp"          \n\t"\
+        "mov    "tmpbyte"   , "statep"                                  \n\t"\
+        "shl    %%cl        , "low"                                     \n\t"\
+        "test   "lowword"   , "lowword"                                 \n\t"\
+        " jnz   1f                                                      \n\t"\
+        "mov "byte"("cabac"), %%"REG_c"                                 \n\t"\
+        "movzwl (%%"REG_c")     , "tmp"                                 \n\t"\
+        "bswap  "tmp"                                                   \n\t"\
+        "shr    $15         , "tmp"                                     \n\t"\
+        "sub    $0xFFFF     , "tmp"                                     \n\t"\
+        "add    $2          , %%"REG_c"                                 \n\t"\
+        "mov    %%"REG_c"   , "byte    "("cabac")                       \n\t"\
+        "lea    -1("low")   , %%ecx                                     \n\t"\
+        "xor    "low"       , %%ecx                                     \n\t"\
+        "shr    $15         , %%ecx                                     \n\t"\
+        "movzbl " MANGLE(ff_h264_norm_shift) "(%%ecx), %%ecx            \n\t"\
+        "neg    %%ecx                                                   \n\t"\
+        "add    $7          , %%ecx                                     \n\t"\
+        "shl    %%cl        , "tmp"                                     \n\t"\
+        "add    "tmp"       , "low"                                     \n\t"\
+        "1:                                                             \n\t"
+
+#if ARCH_X86 && HAVE_7REGS && !defined(BROKEN_RELOCATIONS)
+#define get_cabac_inline get_cabac_inline_x86
+static av_always_inline int get_cabac_inline_x86(CABACContext *c,
+                                                 uint8_t *const state)
+{
+    int bit, low, range, tmp;
+
+    __asm__ volatile(
+        "movl %a6(%5), %2               \n\t"
+        "movl %a7(%5), %1               \n\t"
+        BRANCHLESS_GET_CABAC("%0", "%5", "(%4)", "%1", "%w1", "%2",
+                             "%3", "%b3", "%a8")
+        "movl %2, %a6(%5)               \n\t"
+        "movl %1, %a7(%5)               \n\t"
+
+        :"=&r"(bit), "=&r"(low), "=&r"(range), "=&q"(tmp)
+        :"r"(state), "r"(c),
+         "i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),
+         "i"(offsetof(CABACContext, bytestream))
+        : "%"REG_c, "memory"
+    );
+    return bit & 1;
+}
+#endif /* ARCH_X86 && HAVE_7REGS && !defined(BROKEN_RELOCATIONS) */
+
+#define get_cabac_bypass_sign get_cabac_bypass_sign_x86
+static av_always_inline int get_cabac_bypass_sign_x86(CABACContext *c, int val)
+{
+    x86_reg tmp;
+    __asm__ volatile(
+        "movl %a3(%2), %k1                      \n\t"
+        "movl %a4(%2), %%eax                    \n\t"
+        "shl $17, %k1                           \n\t"
+        "add %%eax, %%eax                       \n\t"
+        "sub %k1, %%eax                         \n\t"
+        "cltd                                   \n\t"
+        "and %%edx, %k1                         \n\t"
+        "add %k1, %%eax                         \n\t"
+        "xor %%edx, %%ecx                       \n\t"
+        "sub %%edx, %%ecx                       \n\t"
+        "test %%ax, %%ax                        \n\t"
+        " jnz 1f                                \n\t"
+        "mov  %a5(%2), %1                       \n\t"
+        "subl $0xFFFF, %%eax                    \n\t"
+        "movzwl (%1), %%edx                     \n\t"
+        "bswap %%edx                            \n\t"
+        "shrl $15, %%edx                        \n\t"
+        "add  $2, %1                            \n\t"
+        "addl %%edx, %%eax                      \n\t"
+        "mov  %1, %a5(%2)                       \n\t"
+        "1:                                     \n\t"
+        "movl %%eax, %a4(%2)                    \n\t"
+
+        :"+c"(val), "=&r"(tmp)
+        :"r"(c),
+         "i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),
+         "i"(offsetof(CABACContext, bytestream))
+        : "%eax", "%edx", "memory"
+    );
+    return val;
+}
+
+#endif /* AVCODEC_X86_CABAC_H */

libavcodec/x86/h264_i386.h

@@ -29,63 +29,72 @@
 #ifndef AVCODEC_X86_H264_I386_H
 #define AVCODEC_X86_H264_I386_H
 
+#include <stddef.h>
+
 #include "libavcodec/cabac.h"
+#include "cabac.h"
 
 //FIXME use some macros to avoid duplicating get_cabac (cannot be done yet
 //as that would make optimization work hard)
-#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
+#if ARCH_X86 && HAVE_7REGS && !defined(BROKEN_RELOCATIONS)
 static int decode_significance_x86(CABACContext *c, int max_coeff,
                                    uint8_t *significant_coeff_ctx_base,
                                    int *index, x86_reg last_off){
     void *end= significant_coeff_ctx_base + max_coeff - 1;
-    int minusstart= -(int)significant_coeff_ctx_base;
-    int minusindex= 4-(int)index;
-    int coeff_count;
+    int minusstart= -(intptr_t)significant_coeff_ctx_base;
+    int minusindex= 4-(intptr_t)index;
+    int bit;
+    x86_reg coeff_count;
+    int low;
+    int range;
     __asm__ volatile(
-        "movl "RANGE    "(%3), %%esi            \n\t"
-        "movl "LOW      "(%3), %%ebx            \n\t"
+        "movl %a11(%6), %5                      \n\t"
+        "movl %a12(%6), %3                      \n\t"
 
         "2:                                     \n\t"
 
-        BRANCHLESS_GET_CABAC("%%edx", "%3", "(%1)", "%%ebx",
-                             "%%bx", "%%esi", "%%eax", "%%al")
+        BRANCHLESS_GET_CABAC("%4", "%6", "(%1)", "%3",
+                             "%w3", "%5", "%k0", "%b0", "%a13")
 
-        "test $1, %%edx                         \n\t"
+        "test $1, %4                            \n\t"
         " jz 3f                                 \n\t"
-        "add  %7, %1                            \n\t"
+        "add  %10, %1                           \n\t"
 
-        BRANCHLESS_GET_CABAC("%%edx", "%3", "(%1)", "%%ebx",
-                             "%%bx", "%%esi", "%%eax", "%%al")
+        BRANCHLESS_GET_CABAC("%4", "%6", "(%1)", "%3",
+                             "%w3", "%5", "%k0", "%b0", "%a13")
 
-        "sub  %7, %1                            \n\t"
-        "mov  %2, %%"REG_a"                     \n\t"
-        "movl %4, %%ecx                         \n\t"
+        "sub  %10, %1                           \n\t"
+        "mov  %2, %0                            \n\t"
+        "movl %7, %%ecx                         \n\t"
         "add  %1, %%"REG_c"                     \n\t"
-        "movl %%ecx, (%%"REG_a")                \n\t"
+        "movl %%ecx, (%0)                       \n\t"
 
-        "test $1, %%edx                         \n\t"
+        "test $1, %4                            \n\t"
         " jnz 4f                                \n\t"
 
-        "add  $4, %%"REG_a"                     \n\t"
-        "mov  %%"REG_a", %2                     \n\t"
+        "add  $4, %0                            \n\t"
+        "mov  %0, %2                            \n\t"
 
         "3:                                     \n\t"
         "add  $1, %1                            \n\t"
-        "cmp  %5, %1                            \n\t"
+        "cmp  %8, %1                            \n\t"
         " jb 2b                                 \n\t"
-        "mov  %2, %%"REG_a"                     \n\t"
-        "movl %4, %%ecx                         \n\t"
+        "mov  %2, %0                            \n\t"
+        "movl %7, %%ecx                         \n\t"
         "add  %1, %%"REG_c"                     \n\t"
-        "movl %%ecx, (%%"REG_a")                \n\t"
+        "movl %%ecx, (%0)                       \n\t"
         "4:                                     \n\t"
-        "add  %6, %%eax                         \n\t"
-        "shr $2, %%eax                          \n\t"
-
-        "movl %%esi, "RANGE    "(%3)            \n\t"
-        "movl %%ebx, "LOW      "(%3)            \n\t"
-        :"=&a"(coeff_count), "+r"(significant_coeff_ctx_base), "+m"(index)
-        :"r"(c), "m"(minusstart), "m"(end), "m"(minusindex), "m"(last_off)
-        : "%"REG_c, "%ebx", "%edx", "%esi", "memory"
+        "add  %9, %k0                           \n\t"
+        "shr $2, %k0                            \n\t"
+
+        "movl %5, %a11(%6)                      \n\t"
+        "movl %3, %a12(%6)                      \n\t"
+        :"=&q"(coeff_count), "+r"(significant_coeff_ctx_base), "+m"(index),
+         "=&r"(low), "=&r"(bit), "=&r"(range)
+        :"r"(c), "m"(minusstart), "m"(end), "m"(minusindex), "m"(last_off),
+         "i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),
+         "i"(offsetof(CABACContext, bytestream))
+        : "%"REG_c, "memory"
     );
     return coeff_count;
 }
@@ -93,64 +102,70 @@ static int decode_significance_x86(CABACContext *c, int max_coeff,
 static int decode_significance_8x8_x86(CABACContext *c,
                                        uint8_t *significant_coeff_ctx_base,
                                        int *index, x86_reg last_off, const uint8_t *sig_off){
-    int minusindex= 4-(int)index;
-    int coeff_count;
+    int minusindex= 4-(intptr_t)index;
+    int bit;
+    x86_reg coeff_count;
+    int low;
+    int range;
     x86_reg last=0;
+    x86_reg state;
     __asm__ volatile(
-        "movl "RANGE    "(%3), %%esi            \n\t"
-        "movl "LOW      "(%3), %%ebx            \n\t"
+        "movl %a12(%7), %5                      \n\t"
+        "movl %a13(%7), %3                      \n\t"
 
-        "mov %1, %%"REG_D"                      \n\t"
+        "mov %1, %6                             \n\t"
         "2:                                     \n\t"
 
-        "mov %6, %%"REG_a"                      \n\t"
-        "movzbl (%%"REG_a", %%"REG_D"), %%edi   \n\t"
-        "add %5, %%"REG_D"                      \n\t"
+        "mov %10, %0                            \n\t"
+        "movzbl (%0, %6), %k6                   \n\t"
+        "add %9, %6                             \n\t"
 
-        BRANCHLESS_GET_CABAC("%%edx", "%3", "(%%"REG_D")", "%%ebx",
-                             "%%bx", "%%esi", "%%eax", "%%al")
+        BRANCHLESS_GET_CABAC("%4", "%7", "(%6)", "%3",
+                             "%w3", "%5", "%k0", "%b0", "%a14")
 
-        "mov %1, %%edi                          \n\t"
-        "test $1, %%edx                         \n\t"
+        "mov %1, %k6                            \n\t"
+        "test $1, %4                            \n\t"
         " jz 3f                                 \n\t"
 
-        "movzbl "MANGLE(last_coeff_flag_offset_8x8)"(%%edi), %%edi\n\t"
-        "add %5, %%"REG_D"                      \n\t"
-        "add %7, %%"REG_D"                      \n\t"
+        "movzbl "MANGLE(last_coeff_flag_offset_8x8)"(%k6), %k6\n\t"
+        "add %9, %6                             \n\t"
+        "add %11, %6                            \n\t"
 
-        BRANCHLESS_GET_CABAC("%%edx", "%3", "(%%"REG_D")", "%%ebx",
-                             "%%bx", "%%esi", "%%eax", "%%al")
+        BRANCHLESS_GET_CABAC("%4", "%7", "(%6)", "%3",
+                             "%w3", "%5", "%k0", "%b0", "%a14")
 
-        "mov %2, %%"REG_a"                      \n\t"
-        "mov %1, %%edi                          \n\t"
-        "movl %%edi, (%%"REG_a")                \n\t"
+        "mov %2, %0                             \n\t"
+        "mov %1, %k6                            \n\t"
+        "movl %k6, (%0)                         \n\t"
 
-        "test $1, %%edx                         \n\t"
+        "test $1, %4                            \n\t"
         " jnz 4f                                \n\t"
 
-        "add $4, %%"REG_a"                      \n\t"
-        "mov %%"REG_a", %2                      \n\t"
+        "add $4, %0                             \n\t"
+        "mov %0, %2                             \n\t"
 
         "3:                                     \n\t"
-        "addl $1, %%edi                         \n\t"
-        "mov %%edi, %1                          \n\t"
-        "cmpl $63, %%edi                        \n\t"
+        "addl $1, %k6                           \n\t"
+        "mov %k6, %1                            \n\t"
+        "cmpl $63, %k6                          \n\t"
         " jb 2b                                 \n\t"
-        "mov %2, %%"REG_a"                      \n\t"
-        "movl %%edi, (%%"REG_a")                \n\t"
+        "mov %2, %0                             \n\t"
+        "movl %k6, (%0)                         \n\t"
         "4:                                     \n\t"
-        "addl %4, %%eax                         \n\t"
-        "shr $2, %%eax                          \n\t"
-
-        "movl %%esi, "RANGE    "(%3)            \n\t"
-        "movl %%ebx, "LOW      "(%3)            \n\t"
-        :"=&a"(coeff_count),"+m"(last), "+m"(index)
-        :"r"(c), "m"(minusindex), "m"(significant_coeff_ctx_base), "m"(sig_off), "m"(last_off)
-        : "%"REG_c, "%ebx", "%edx", "%esi", "%"REG_D, "memory"
+        "addl %8, %k0                           \n\t"
+        "shr $2, %k0                            \n\t"
+
+        "movl %5, %a12(%7)                      \n\t"
+        "movl %3, %a13(%7)                      \n\t"
+        :"=&q"(coeff_count),"+m"(last), "+m"(index), "=&r"(low), "=&r"(bit),
+         "=&r"(range), "=&r"(state)
+        :"r"(c), "m"(minusindex), "m"(significant_coeff_ctx_base), "m"(sig_off), "m"(last_off),
+         "i"(offsetof(CABACContext, range)), "i"(offsetof(CABACContext, low)),
+         "i"(offsetof(CABACContext, bytestream))
+        : "%"REG_c, "memory"
     );
     return coeff_count;
 }
-#endif /* ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE */
-       /* !defined(BROKEN_RELOCATIONS) */
+#endif /* ARCH_X86 && HAVE_7REGS && !defined(BROKEN_RELOCATIONS) */
 
 #endif /* AVCODEC_X86_H264_I386_H */

libavformat/matroskaenc.c

@@ -527,7 +527,7 @@ static int mkv_write_tracks(AVFormatContext *s)
         AVDictionaryEntry *tag;
 
         if (!bit_depth)
-            bit_depth = av_get_bits_per_sample_fmt(codec->sample_fmt);
+            bit_depth = av_get_bytes_per_sample(codec->sample_fmt) << 3;
 
         if (codec->codec_id == CODEC_ID_AAC)
             get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate);

libavformat/mov.c

@@ -2202,7 +2202,7 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             time     = avio_rb64(pb);
         } else {
             duration = avio_rb32(pb); /* segment duration */
-            time     = avio_rb32(pb); /* media time */
+            time     = (int32_t)avio_rb32(pb); /* media time */
         }
         avio_rb32(pb); /* Media rate */
         if (i == 0 && time >= -1) {

libswscale/swscale.h

@@ -29,9 +29,9 @@
 
 #include "libavutil/avutil.h"
 
-#define LIBSWSCALE_VERSION_MAJOR 0
-#define LIBSWSCALE_VERSION_MINOR 14
-#define LIBSWSCALE_VERSION_MICRO 1
+#define LIBSWSCALE_VERSION_MAJOR 2
+#define LIBSWSCALE_VERSION_MINOR 0
+#define LIBSWSCALE_VERSION_MICRO 0
 
 #define LIBSWSCALE_VERSION_INT  AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \
                                                LIBSWSCALE_VERSION_MINOR, \
@@ -48,13 +48,13 @@
  * They may change, break or disappear at any time.
  */
 #ifndef FF_API_SWS_GETCONTEXT
-#define FF_API_SWS_GETCONTEXT  (LIBSWSCALE_VERSION_MAJOR < 2)
+#define FF_API_SWS_GETCONTEXT  (LIBSWSCALE_VERSION_MAJOR < 3)
 #endif
 #ifndef FF_API_SWS_CPU_CAPS
-#define FF_API_SWS_CPU_CAPS    (LIBSWSCALE_VERSION_MAJOR < 2)
+#define FF_API_SWS_CPU_CAPS    (LIBSWSCALE_VERSION_MAJOR < 3)
 #endif
 #ifndef FF_API_SWS_FORMAT_NAME
-#define FF_API_SWS_FORMAT_NAME  (LIBSWSCALE_VERSION_MAJOR < 2)
+#define FF_API_SWS_FORMAT_NAME  (LIBSWSCALE_VERSION_MAJOR < 3)
 #endif
 
 /**