Merge remote-tracking branch 'qatar/master'

* qatar/master:
  os_support: Choose between direct.h and io.h using a configure check
  os_support: Include io.h instead of direct.h on mingw32ce
  x86: ac3dsp: Only refer to the ac3_downmix_sse symbol if it has been declared
  swscale: Remove two bogus asserts
  ac3: move ac3_downmix() from dsputil to ac3dsp
  lavr/audio_mix_matrix: acknowledge the existence of LFE2.
  mlp_parser: avoid mapping multiple disctinct TrueHD channels to the same Libav channel.
  lavu/audioconvert: add a second low frequency channel.

Conflicts:
	doc/APIchanges
	libavcodec/ac3dsp.c
	libavcodec/ac3dsp.h
	libavcodec/mlp_parser.c
	libavutil/audioconvert.c
	libavutil/version.h
Merged-by: Michael Niedermayer <michaelni@gmx.at>

configure

@@ -1276,6 +1276,7 @@ HAVE_LIST="
     dev_ic_bt8xx_h
     dev_video_bktr_ioctl_bt848_h
     dev_video_meteor_ioctl_meteor_h
+    direct_h
     dlfcn_h
     dlopen
     dos_paths
@@ -3504,6 +3505,7 @@ check_func_headers windows.h Sleep
 check_func_headers windows.h VirtualAlloc
 check_func_headers glob.h glob
 
+check_header direct.h
 check_header dlfcn.h
 check_header dxva.h
 check_header dxva2api.h -D_WIN32_WINNT=0x0600

doc/APIchanges

@@ -83,6 +83,9 @@ API changes, most recent first:
 2012-03-26 - a67d9cf - lavfi 2.66.100
   Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.
 
+2012-09-12 - xxxxxxx - lavu 51.41.0 - audioconvert.h
+  Added AV_CH_LOW_FREQUENCY_2 channel mask value.
+
 2012-09-04 - xxxxxxx - lavu 51.40.0 - opt.h
   Reordered the fields in default_val in AVOption, changed which
   default_val field is used for which AVOptionType.

libavcodec/ac3dec.c

@@ -620,34 +620,6 @@ static inline void do_imdct(AC3DecodeContext *s, int channels)
     }
 }
 
-/**
- * Downmix the output to mono or stereo.
- */
-void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2],
-                      int out_ch, int in_ch, int len)
-{
-    int i, j;
-    float v0, v1;
-    if (out_ch == 2) {
-        for (i = 0; i < len; i++) {
-            v0 = v1 = 0.0f;
-            for (j = 0; j < in_ch; j++) {
-                v0 += samples[j][i] * matrix[j][0];
-                v1 += samples[j][i] * matrix[j][1];
-            }
-            samples[0][i] = v0;
-            samples[1][i] = v1;
-        }
-    } else if (out_ch == 1) {
-        for (i = 0; i < len; i++) {
-            v0 = 0.0f;
-            for (j = 0; j < in_ch; j++)
-                v0 += samples[j][i] * matrix[j][0];
-            samples[0][i] = v0;
-        }
-    }
-}
-
 /**
  * Upmix delay samples from stereo to original channel layout.
  */
@@ -1266,19 +1238,19 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
         do_imdct(s, s->channels);
 
         if (downmix_output) {
-            s->dsp.ac3_downmix(s->output, s->downmix_coeffs,
-                               s->out_channels, s->fbw_channels, 256);
+            s->ac3dsp.downmix(s->output, s->downmix_coeffs,
+                              s->out_channels, s->fbw_channels, 256);
         }
     } else {
         if (downmix_output) {
-            s->dsp.ac3_downmix(s->transform_coeffs + 1, s->downmix_coeffs,
-                               s->out_channels, s->fbw_channels, 256);
+            s->ac3dsp.downmix(s->transform_coeffs + 1, s->downmix_coeffs,
+                              s->out_channels, s->fbw_channels, 256);
         }
 
         if (downmix_output && !s->downmixed) {
             s->downmixed = 1;
-            s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels,
-                               s->fbw_channels, 128);
+            s->ac3dsp.downmix(s->delay, s->downmix_coeffs, s->out_channels,
+                              s->fbw_channels, 128);
         }
 
         do_imdct(s, s->out_channels);

libavcodec/ac3dec.h

@@ -227,9 +227,6 @@ int ff_eac3_parse_header(AC3DecodeContext *s);
  */
 void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch);
 
-void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2],
-                      int out_ch, int in_ch, int len);
-
 /**
  * Apply spectral extension to each channel by copying lower frequency
  * coefficients to higher frequency bins and applying side information to

libavcodec/ac3dsp.c

@@ -214,6 +214,31 @@ static void ac3_sum_square_butterfly_float_c(float sum[4],
     }
 }
 
+static void ac3_downmix_c(float (*samples)[256], float (*matrix)[2],
+                          int out_ch, int in_ch, int len)
+{
+    int i, j;
+    float v0, v1;
+    if (out_ch == 2) {
+        for (i = 0; i < len; i++) {
+            v0 = v1 = 0.0f;
+            for (j = 0; j < in_ch; j++) {
+                v0 += samples[j][i] * matrix[j][0];
+                v1 += samples[j][i] * matrix[j][1];
+            }
+            samples[0][i] = v0;
+            samples[1][i] = v1;
+        }
+    } else if (out_ch == 1) {
+        for (i = 0; i < len; i++) {
+            v0 = 0.0f;
+            for (j = 0; j < in_ch; j++)
+                v0 += samples[j][i] * matrix[j][0];
+            samples[0][i] = v0;
+        }
+    }
+}
+
 av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
 {
     c->ac3_exponent_min = ac3_exponent_min_c;
@@ -227,6 +252,7 @@ av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
     c->extract_exponents = ac3_extract_exponents_c;
     c->sum_square_butterfly_int32 = ac3_sum_square_butterfly_int32_c;
     c->sum_square_butterfly_float = ac3_sum_square_butterfly_float_c;
+    c->downmix = ac3_downmix_c;
 
     if (ARCH_ARM)
         ff_ac3dsp_init_arm(c, bit_exact);

libavcodec/ac3dsp.h

@@ -131,6 +131,9 @@ typedef struct AC3DSPContext {
 
     void (*sum_square_butterfly_float)(float sum[4], const float *coef0,
                                        const float *coef1, int len);
+
+    void (*downmix)(float (*samples)[256], float (*matrix)[2], int out_ch,
+                    int in_ch, int len);
 } AC3DSPContext;
 
 void ff_ac3dsp_init    (AC3DSPContext *c, int bit_exact);

libavcodec/dsputil.c

@@ -36,7 +36,6 @@
 #include "mathops.h"
 #include "mpegvideo.h"
 #include "config.h"
-#include "ac3dec.h"
 #include "vorbis.h"
 #include "diracdsp.h"
 
@@ -3032,9 +3031,6 @@ av_cold void ff_dsputil_init(DSPContext* c, AVCodecContext *avctx)
 
 #if CONFIG_VORBIS_DECODER
     c->vorbis_inverse_coupling = ff_vorbis_inverse_coupling;
-#endif
-#if CONFIG_AC3_DECODER
-    c->ac3_downmix = ff_ac3_downmix_c;
 #endif
     c->vector_fmul_reverse = vector_fmul_reverse_c;
     c->vector_fmul_add = vector_fmul_add_c;

libavcodec/dsputil.h

@@ -384,7 +384,6 @@ typedef struct DSPContext {
 
     /* assume len is a multiple of 4, and arrays are 16-byte aligned */
     void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize);
-    void (*ac3_downmix)(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len);
     /* assume len is a multiple of 16, and arrays are 32-byte aligned */
     void (*vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len);
     /* assume len is a multiple of 8, and src arrays are 16-byte aligned */

libavcodec/mlp_parser.c

@@ -83,10 +83,10 @@ static const uint64_t thd_layout[13] = {
     AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT,                       // LRrs
     AV_CH_BACK_CENTER,                                      // Cs
     AV_CH_TOP_CENTER,                                       // Ts
-    AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT,                       // LRsd - TODO: Surround Direct
+    AV_CH_SURROUND_DIRECT_LEFT|AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
     AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT,                       // LRw
     AV_CH_TOP_FRONT_CENTER,                                 // Cvh
-    AV_CH_LOW_FREQUENCY                                     // LFE2
+    AV_CH_LOW_FREQUENCY_2,                                  // LFE2
 };
 
 static int mlp_samplerate(int in)

libavcodec/x86/ac3dsp_init.c

@@ -19,9 +19,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/mem.h"
 #include "libavutil/x86/asm.h"
 #include "libavutil/x86/cpu.h"
 #include "dsputil_mmx.h"
+#include "libavcodec/ac3.h"
 #include "libavcodec/ac3dsp.h"
 
 extern void ff_ac3_exponent_min_mmx   (uint8_t *exp, int num_reuse_blocks, int nb_coefs);
@@ -49,6 +51,119 @@ extern void ff_ac3_extract_exponents_3dnow(uint8_t *exp, int32_t *coef, int nb_c
 extern void ff_ac3_extract_exponents_sse2 (uint8_t *exp, int32_t *coef, int nb_coefs);
 extern void ff_ac3_extract_exponents_ssse3(uint8_t *exp, int32_t *coef, int nb_coefs);
 
+#if HAVE_SSE_INLINE
+
+#define IF1(x) x
+#define IF0(x)
+
+#define MIX5(mono, stereo)                                      \
+    __asm__ volatile (                                          \
+        "movss           0(%2), %%xmm5          \n"             \
+        "movss           8(%2), %%xmm6          \n"             \
+        "movss          24(%2), %%xmm7          \n"             \
+        "shufps     $0, %%xmm5, %%xmm5          \n"             \
+        "shufps     $0, %%xmm6, %%xmm6          \n"             \
+        "shufps     $0, %%xmm7, %%xmm7          \n"             \
+        "1:                                     \n"             \
+        "movaps       (%0, %1), %%xmm0          \n"             \
+        "movaps  0x400(%0, %1), %%xmm1          \n"             \
+        "movaps  0x800(%0, %1), %%xmm2          \n"             \
+        "movaps  0xc00(%0, %1), %%xmm3          \n"             \
+        "movaps 0x1000(%0, %1), %%xmm4          \n"             \
+        "mulps          %%xmm5, %%xmm0          \n"             \
+        "mulps          %%xmm6, %%xmm1          \n"             \
+        "mulps          %%xmm5, %%xmm2          \n"             \
+        "mulps          %%xmm7, %%xmm3          \n"             \
+        "mulps          %%xmm7, %%xmm4          \n"             \
+ stereo("addps          %%xmm1, %%xmm0          \n")            \
+        "addps          %%xmm1, %%xmm2          \n"             \
+        "addps          %%xmm3, %%xmm0          \n"             \
+        "addps          %%xmm4, %%xmm2          \n"             \
+   mono("addps          %%xmm2, %%xmm0          \n")            \
+        "movaps         %%xmm0, (%0, %1)        \n"             \
+ stereo("movaps         %%xmm2, 0x400(%0, %1)   \n")            \
+        "add               $16, %0              \n"             \
+        "jl                 1b                  \n"             \
+        : "+&r"(i)                                              \
+        : "r"(samples[0] + len), "r"(matrix)                    \
+        : XMM_CLOBBERS("%xmm0", "%xmm1", "%xmm2", "%xmm3",      \
+                      "%xmm4", "%xmm5", "%xmm6", "%xmm7",)      \
+         "memory"                                               \
+    );
+
+#define MIX_MISC(stereo)                                        \
+    __asm__ volatile (                                          \
+        "1:                                 \n"                 \
+        "movaps     (%3, %0), %%xmm0        \n"                 \
+ stereo("movaps       %%xmm0, %%xmm1        \n")                \
+        "mulps        %%xmm4, %%xmm0        \n"                 \
+ stereo("mulps        %%xmm5, %%xmm1        \n")                \
+        "lea    1024(%3, %0), %1            \n"                 \
+        "mov              %5, %2            \n"                 \
+        "2:                                 \n"                 \
+        "movaps         (%1), %%xmm2        \n"                 \
+ stereo("movaps       %%xmm2, %%xmm3        \n")                \
+        "mulps      (%4, %2), %%xmm2        \n"                 \
+ stereo("mulps    16(%4, %2), %%xmm3        \n")                \
+        "addps        %%xmm2, %%xmm0        \n"                 \
+ stereo("addps        %%xmm3, %%xmm1        \n")                \
+        "add           $1024, %1            \n"                 \
+        "add             $32, %2            \n"                 \
+        "jl               2b                \n"                 \
+        "movaps       %%xmm0,     (%3, %0)  \n"                 \
+ stereo("movaps       %%xmm1, 1024(%3, %0)  \n")                \
+        "add             $16, %0            \n"                 \
+        "jl               1b                \n"                 \
+        : "+&r"(i), "=&r"(j), "=&r"(k)                          \
+        : "r"(samples[0] + len), "r"(matrix_simd + in_ch),      \
+          "g"((intptr_t) - 32 * (in_ch - 1))                    \
+        : "memory"                                              \
+    );
+
+static void ac3_downmix_sse(float (*samples)[256], float (*matrix)[2],
+                            int out_ch, int in_ch, int len)
+{
+    int (*matrix_cmp)[2] = (int(*)[2])matrix;
+    intptr_t i, j, k;
+
+    i = -len * sizeof(float);
+    if (in_ch == 5 && out_ch == 2 &&
+        !(matrix_cmp[0][1] | matrix_cmp[2][0]   |
+          matrix_cmp[3][1] | matrix_cmp[4][0]   |
+          (matrix_cmp[1][0] ^ matrix_cmp[1][1]) |
+          (matrix_cmp[0][0] ^ matrix_cmp[2][1]))) {
+        MIX5(IF0, IF1);
+    } else if (in_ch == 5 && out_ch == 1 &&
+               matrix_cmp[0][0] == matrix_cmp[2][0] &&
+               matrix_cmp[3][0] == matrix_cmp[4][0]) {
+        MIX5(IF1, IF0);
+    } else {
+        DECLARE_ALIGNED(16, float, matrix_simd)[AC3_MAX_CHANNELS][2][4];
+        j = 2 * in_ch * sizeof(float);
+        __asm__ volatile (
+            "1:                                 \n"
+            "sub             $8, %0             \n"
+            "movss     (%2, %0), %%xmm4         \n"
+            "movss    4(%2, %0), %%xmm5         \n"
+            "shufps          $0, %%xmm4, %%xmm4 \n"
+            "shufps          $0, %%xmm5, %%xmm5 \n"
+            "movaps      %%xmm4,   (%1, %0, 4)  \n"
+            "movaps      %%xmm5, 16(%1, %0, 4)  \n"
+            "jg              1b                 \n"
+            : "+&r"(j)
+            : "r"(matrix_simd), "r"(matrix)
+            : "memory"
+        );
+        if (out_ch == 2) {
+            MIX_MISC(IF1);
+        } else {
+            MIX_MISC(IF0);
+        }
+    }
+}
+
+#endif /* HAVE_SSE_INLINE */
+
 av_cold void ff_ac3dsp_init_x86(AC3DSPContext *c, int bit_exact)
 {
     int mm_flags = av_get_cpu_flags();
@@ -89,4 +204,10 @@ av_cold void ff_ac3dsp_init_x86(AC3DSPContext *c, int bit_exact)
             c->extract_exponents = ff_ac3_extract_exponents_ssse3;
         }
     }
+
+#if HAVE_SSE_INLINE
+    if (INLINE_SSE(mm_flags)) {
+        c->downmix = ac3_downmix_sse;
+    }
+#endif
 }

libavcodec/x86/dsputil_mmx.c

@@ -28,7 +28,6 @@
 #include "libavcodec/h264dsp.h"
 #include "libavcodec/mpegvideo.h"
 #include "libavcodec/simple_idct.h"
-#include "libavcodec/ac3dec.h"
 #include "dsputil_mmx.h"
 #include "idct_xvid.h"
 #include "diracdsp_mmx.h"
@@ -2375,115 +2374,6 @@ static void vorbis_inverse_coupling_sse(float *mag, float *ang, int blocksize)
     }
 }
 
-#define IF1(x) x
-#define IF0(x)
-
-#define MIX5(mono, stereo)                                      \
-    __asm__ volatile (                                          \
-        "movss           0(%2), %%xmm5          \n"             \
-        "movss           8(%2), %%xmm6          \n"             \
-        "movss          24(%2), %%xmm7          \n"             \
-        "shufps     $0, %%xmm5, %%xmm5          \n"             \
-        "shufps     $0, %%xmm6, %%xmm6          \n"             \
-        "shufps     $0, %%xmm7, %%xmm7          \n"             \
-        "1:                                     \n"             \
-        "movaps       (%0, %1), %%xmm0          \n"             \
-        "movaps  0x400(%0, %1), %%xmm1          \n"             \
-        "movaps  0x800(%0, %1), %%xmm2          \n"             \
-        "movaps  0xc00(%0, %1), %%xmm3          \n"             \
-        "movaps 0x1000(%0, %1), %%xmm4          \n"             \
-        "mulps          %%xmm5, %%xmm0          \n"             \
-        "mulps          %%xmm6, %%xmm1          \n"             \
-        "mulps          %%xmm5, %%xmm2          \n"             \
-        "mulps          %%xmm7, %%xmm3          \n"             \
-        "mulps          %%xmm7, %%xmm4          \n"             \
- stereo("addps          %%xmm1, %%xmm0          \n")            \
-        "addps          %%xmm1, %%xmm2          \n"             \
-        "addps          %%xmm3, %%xmm0          \n"             \
-        "addps          %%xmm4, %%xmm2          \n"             \
-   mono("addps          %%xmm2, %%xmm0          \n")            \
-        "movaps         %%xmm0, (%0, %1)        \n"             \
- stereo("movaps         %%xmm2, 0x400(%0, %1)   \n")            \
-        "add               $16, %0              \n"             \
-        "jl                 1b                  \n"             \
-        : "+&r"(i)                                              \
-        : "r"(samples[0] + len), "r"(matrix)                    \
-        : XMM_CLOBBERS("%xmm0", "%xmm1", "%xmm2", "%xmm3",      \
-                      "%xmm4", "%xmm5", "%xmm6", "%xmm7",)      \
-         "memory"                                               \
-    );
-
-#define MIX_MISC(stereo)                                        \
-    __asm__ volatile (                                          \
-        "1:                                 \n"                 \
-        "movaps     (%3, %0), %%xmm0        \n"                 \
- stereo("movaps       %%xmm0, %%xmm1        \n")                \
-        "mulps        %%xmm4, %%xmm0        \n"                 \
- stereo("mulps        %%xmm5, %%xmm1        \n")                \
-        "lea    1024(%3, %0), %1            \n"                 \
-        "mov              %5, %2            \n"                 \
-        "2:                                 \n"                 \
-        "movaps         (%1), %%xmm2        \n"                 \
- stereo("movaps       %%xmm2, %%xmm3        \n")                \
-        "mulps      (%4, %2), %%xmm2        \n"                 \
- stereo("mulps    16(%4, %2), %%xmm3        \n")                \
-        "addps        %%xmm2, %%xmm0        \n"                 \
- stereo("addps        %%xmm3, %%xmm1        \n")                \
-        "add           $1024, %1            \n"                 \
-        "add             $32, %2            \n"                 \
-        "jl               2b                \n"                 \
-        "movaps       %%xmm0,     (%3, %0)  \n"                 \
- stereo("movaps       %%xmm1, 1024(%3, %0)  \n")                \
-        "add             $16, %0            \n"                 \
-        "jl               1b                \n"                 \
-        : "+&r"(i), "=&r"(j), "=&r"(k)                          \
-        : "r"(samples[0] + len), "r"(matrix_simd + in_ch),      \
-          "g"((intptr_t) - 32 * (in_ch - 1))                    \
-        : "memory"                                              \
-    );
-
-static void ac3_downmix_sse(float (*samples)[256], float (*matrix)[2],
-                            int out_ch, int in_ch, int len)
-{
-    int (*matrix_cmp)[2] = (int(*)[2])matrix;
-    intptr_t i, j, k;
-
-    i = -len * sizeof(float);
-    if (in_ch == 5 && out_ch == 2 &&
-        !(matrix_cmp[0][1] | matrix_cmp[2][0]   |
-          matrix_cmp[3][1] | matrix_cmp[4][0]   |
-          (matrix_cmp[1][0] ^ matrix_cmp[1][1]) |
-          (matrix_cmp[0][0] ^ matrix_cmp[2][1]))) {
-        MIX5(IF0, IF1);
-    } else if (in_ch == 5 && out_ch == 1 &&
-               matrix_cmp[0][0] == matrix_cmp[2][0] &&
-               matrix_cmp[3][0] == matrix_cmp[4][0]) {
-        MIX5(IF1, IF0);
-    } else {
-        DECLARE_ALIGNED(16, float, matrix_simd)[AC3_MAX_CHANNELS][2][4];
-        j = 2 * in_ch * sizeof(float);
-        __asm__ volatile (
-            "1:                                 \n"
-            "sub             $8, %0             \n"
-            "movss     (%2, %0), %%xmm4         \n"
-            "movss    4(%2, %0), %%xmm5         \n"
-            "shufps          $0, %%xmm4, %%xmm4 \n"
-            "shufps          $0, %%xmm5, %%xmm5 \n"
-            "movaps      %%xmm4,   (%1, %0, 4)  \n"
-            "movaps      %%xmm5, 16(%1, %0, 4)  \n"
-            "jg              1b                 \n"
-            : "+&r"(j)
-            : "r"(matrix_simd), "r"(matrix)
-            : "memory"
-        );
-        if (out_ch == 2) {
-            MIX_MISC(IF1);
-        } else {
-            MIX_MISC(IF0);
-        }
-    }
-}
-
 #if HAVE_6REGS
 static void vector_fmul_window_3dnowext(float *dst, const float *src0,
                                         const float *src1, const float *win,
@@ -2958,7 +2848,6 @@ static void dsputil_init_sse(DSPContext *c, AVCodecContext *avctx, int mm_flags)
     }
 
     c->vorbis_inverse_coupling = vorbis_inverse_coupling_sse;
-    c->ac3_downmix             = ac3_downmix_sse;
 
 #if HAVE_6REGS
     c->vector_fmul_window = vector_fmul_window_sse;

libavformat/os_support.h

@@ -48,7 +48,11 @@
 #endif /* defined(__MINGW32__) && !defined(__MINGW32CE__) */
 
 #ifdef _WIN32
+#if HAVE_DIRECT_H
 #include <direct.h>
+#elif HAVE_IO_H
+#include <io.h>
+#endif
 #define mkdir(a, b) _mkdir(a)
 #else
 #include <sys/stat.h>

libavresample/audio_mix_matrix.c

@@ -54,6 +54,7 @@
 #define WIDE_RIGHT             32
 #define SURROUND_DIRECT_LEFT   33
 #define SURROUND_DIRECT_RIGHT  34
+#define LOW_FREQUENCY_2        35
 
 #define SQRT3_2      1.22474487139158904909  /* sqrt(3/2) */
 

libavutil/audioconvert.c

@@ -59,6 +59,7 @@ static const struct channel_name channel_names[] = {
     [32] = { "WR",        "wide right"            },
     [33] = { "SDL",       "surround direct left"  },
     [34] = { "SDR",       "surround direct right" },
+    [35] = { "LFE2",      "low frequency 2"       },
 };
 
 static const char *get_channel_name(int channel_id)

libavutil/audioconvert.h

@@ -62,6 +62,7 @@
 #define AV_CH_WIDE_RIGHT             0x0000000100000000ULL
 #define AV_CH_SURROUND_DIRECT_LEFT   0x0000000200000000ULL
 #define AV_CH_SURROUND_DIRECT_RIGHT  0x0000000400000000ULL
+#define AV_CH_LOW_FREQUENCY_2        0x0000000800000000ULL
 
 /** Channel mask value used for AVCodecContext.request_channel_layout
     to indicate that the user requests the channel order of the decoder output

libavutil/version.h

@@ -39,7 +39,7 @@
  */
 
 #define LIBAVUTIL_VERSION_MAJOR 51
-#define LIBAVUTIL_VERSION_MINOR 72
+#define LIBAVUTIL_VERSION_MINOR 73
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

libswscale/swscale.c

@@ -628,8 +628,6 @@ static int swScale(SwsContext *c, const uint8_t *src[],
                     }
                 }
             } else {
-                assert(lumSrcPtr  + vLumFilterSize - 1 < lumPixBuf  + vLumBufSize * 2);
-                assert(chrUSrcPtr + vChrFilterSize - 1 < chrUPixBuf + vChrBufSize * 2);
                 if (c->yuv2packed1 && vLumFilterSize == 1 &&
                     vChrFilterSize <= 2) { // unscaled RGB
                     int chrAlpha = vChrFilterSize == 1 ? 0 : vChrFilter[2 * dstY + 1];