Merge commit '9c12c6ff9539e926df0b2a2299e915ae71872600'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 24 Nov 2014 10:39:26 +0000 (11:39 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 24 Nov 2014 11:13:00 +0000 (12:13 +0100)
* commit '9c12c6ff9539e926df0b2a2299e915ae71872600':
  motion_est: convert stride to ptrdiff_t

Conflicts:
libavcodec/me_cmp.c
libavcodec/ppc/me_cmp.c
libavcodec/x86/me_cmp_init.c

See: 9c669672c7fd45ef1cad782ab551be438ceac6cd
Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/arm/me_cmp_init_arm.c
libavcodec/me_cmp.c
libavcodec/me_cmp.h
libavcodec/motion_est.c
libavcodec/ppc/me_cmp.c
libavcodec/snow_dwt.c
libavcodec/snow_dwt.h
libavcodec/x86/me_cmp.asm
libavcodec/x86/me_cmp_init.c

Simple merge
@@@ -814,24 -803,20 +816,24 @@@ static int vsad_intra ## size ## _c(Mpe
  VSAD_INTRA(8)
  VSAD_INTRA(16)
  
 -static int vsad16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
 -                    ptrdiff_t stride, int h)
 -{
 -    int score = 0, x, y;
 -
 -    for (y = 1; y < h; y++) {
 -        for (x = 0; x < 16; x++)
 -            score += FFABS(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);
 -        s1 += stride;
 -        s2 += stride;
 -    }
 -
 -    return score;
 +#define VSAD(size)                                                             \
 +static int vsad ## size ## _c(MpegEncContext *c,                               \
 +                              uint8_t *s1, uint8_t *s2,                        \
-                               int stride, int h)                               \
++                              ptrdiff_t stride, int h)                               \
 +{                                                                              \
 +    int score = 0, x, y;                                                       \
 +                                                                               \
 +    for (y = 1; y < h; y++) {                                                  \
 +        for (x = 0; x < size; x++)                                             \
 +            score += FFABS(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);   \
 +        s1 += stride;                                                          \
 +        s2 += stride;                                                          \
 +    }                                                                          \
 +                                                                               \
 +    return score;                                                              \
  }
 +VSAD(8)
 +VSAD(16)
  
  #define SQ(a) ((a) * (a))
  #define VSSE_INTRA(size)                                                \
@@@ -856,23 -841,20 +858,23 @@@ static int vsse_intra ## size ## _c(Mpe
  VSSE_INTRA(8)
  VSSE_INTRA(16)
  
 -static int vsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
 -                    ptrdiff_t stride, int h)
 -{
 -    int score = 0, x, y;
 -
 -    for (y = 1; y < h; y++) {
 -        for (x = 0; x < 16; x++)
 -            score += SQ(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);
 -        s1 += stride;
 -        s2 += stride;
 -    }
 -
 -    return score;
 +#define VSSE(size)                                                             \
 +static int vsse ## size ## _c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,     \
-                     int stride, int h)                                         \
++                              ptrdiff_t stride, int h)                         \
 +{                                                                              \
 +    int score = 0, x, y;                                                       \
 +                                                                               \
 +    for (y = 1; y < h; y++) {                                                  \
 +        for (x = 0; x < size; x++)                                             \
 +            score += SQ(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);      \
 +        s1 += stride;                                                          \
 +        s2 += stride;                                                          \
 +    }                                                                          \
 +                                                                               \
 +    return score;                                                              \
  }
 +VSSE(8)
 +VSSE(16)
  
  #define WRAPPER8_16_SQ(name8, name16)                                   \
  static int name16(MpegEncContext *s, uint8_t *dst, uint8_t *src,        \
Simple merge
@@@ -290,7 -290,7 +290,7 @@@ static int cmp_qpel(MpegEncContext *s, 
  #include "motion_est_template.c"
  
  static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b,
--                    int stride, int h)
++                    ptrdiff_t stride, int h)
  {
      return 0;
  }
  #include "libavcodec/me_cmp.h"
  
  #if HAVE_ALTIVEC
 +
 +#if HAVE_BIGENDIAN
 +#define GET_PERM(per1, per2, pix) {\
 +    per1 = vec_lvsl(0, pix);\
 +    per2 = vec_add(per1, vec_splat_u8(1));\
 +}
 +#define LOAD_PIX(v, iv, pix, per1, per2) {\
 +    vector unsigned char pix2l  = vec_ld(0,  pix);\
 +    vector unsigned char pix2r  = vec_ld(16, pix);\
 +    v  = vec_perm(pix2l, pix2r, per1);\
 +    iv = vec_perm(pix2l, pix2r, per2);\
 +}
 +#else
 +#define GET_PERM(per1, per2, pix) {}
 +#define LOAD_PIX(v, iv, pix, per1, per2) {\
 +    v  = vec_vsx_ld(0,  pix);\
 +    iv = vec_vsx_ld(1,  pix);\
 +}
 +#endif
  static int sad16_x2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                             int line_size, int h)
+                             ptrdiff_t stride, int h)
  {
 -    int i, s = 0;
 +    int i;
 +    int __attribute__((aligned(16))) s = 0;
      const vector unsigned char zero =
          (const vector unsigned char) vec_splat_u8(0);
 -    vector unsigned char perm1 = vec_lvsl(0, pix2);
 -    vector unsigned char perm2 = vec_add(perm1, vec_splat_u8(1));
      vector unsigned int sad = (vector unsigned int) vec_splat_u32(0);
      vector signed int sumdiffs;
 +    vector unsigned char perm1, perm2, pix2v, pix2iv;
  
 +    GET_PERM(perm1, perm2, pix2);
      for (i = 0; i < h; i++) {
          /* Read unaligned pixels into our vectors. The vectors are as follows:
           * pix1v: pix1[0] - pix1[15]
  }
  
  static int sad16_y2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                             int line_size, int h)
+                             ptrdiff_t stride, int h)
  {
 -    int i, s = 0;
 +    int i;
 +    int  __attribute__((aligned(16))) s = 0;
      const vector unsigned char zero =
          (const vector unsigned char) vec_splat_u8(0);
 -    vector unsigned char perm = vec_lvsl(0, pix2);
      vector unsigned char pix1v, pix3v, avgv, t5;
      vector unsigned int sad = (vector unsigned int) vec_splat_u32(0);
      vector signed int sumdiffs;
-     uint8_t *pix3 = pix2 + line_size;
 +
+     uint8_t *pix3 = pix2 + stride;
  
-     /* Due to the fact that pix3 = pix2 + line_size, the pix3 of one
+     /* Due to the fact that pix3 = pix2 + stride, the pix3 of one
       * iteration becomes pix2 in the next iteration. We can use this
       * fact to avoid a potentially expensive unaligned read, each
       * time around the loop.
  }
  
  static int sad16_xy2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                              int line_size, int h)
+                              ptrdiff_t stride, int h)
  {
 -    int i, s = 0;
 +    int i;
 +    int  __attribute__((aligned(16))) s = 0;
-     uint8_t *pix3 = pix2 + line_size;
+     uint8_t *pix3 = pix2 + stride;
      const vector unsigned char zero =
          (const vector unsigned char) vec_splat_u8(0);
      const vector unsigned short two =
      vector unsigned short avghv, avglv;
      vector unsigned int sad = (vector unsigned int) vec_splat_u32(0);
      vector signed int sumdiffs;
 +    vector unsigned char perm1, perm2, pix2v, pix2iv;
 +    GET_PERM(perm1, perm2, pix2);
  
-     /* Due to the fact that pix3 = pix2 + line_size, the pix3 of one
+     /* Due to the fact that pix3 = pix2 + stride, the pix3 of one
       * iteration becomes pix2 in the next iteration. We can use this
       * fact to avoid a potentially expensive unaligned read, as well
       * as some splitting, and vector addition each time around the loop.
  }
  
  static int sad16_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                          int line_size, int h)
+                          ptrdiff_t stride, int h)
  {
 -    int i, s;
 +    int i;
 +    int  __attribute__((aligned(16))) s;
      const vector unsigned int zero =
          (const vector unsigned int) vec_splat_u32(0);
 -    vector unsigned char perm = vec_lvsl(0, pix2);
      vector unsigned int sad = (vector unsigned int) vec_splat_u32(0);
      vector signed int sumdiffs;
  
  }
  
  static int sad8_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                         int line_size, int h)
+                         ptrdiff_t stride, int h)
  {
 -    int i, s;
 +    int i;
 +    int  __attribute__((aligned(16))) s;
      const vector unsigned int zero =
          (const vector unsigned int) vec_splat_u32(0);
      const vector unsigned char permclear =
  /* Sum of Squared Errors for an 8x8 block, AltiVec-enhanced.
   * It's the sad8_altivec code above w/ squaring added. */
  static int sse8_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                         int line_size, int h)
+                         ptrdiff_t stride, int h)
  {
 -    int i, s;
 +    int i;
 +    int  __attribute__((aligned(16))) s;
      const vector unsigned int zero =
          (const vector unsigned int) vec_splat_u32(0);
      const vector unsigned char permclear =
  /* Sum of Squared Errors for a 16x16 block, AltiVec-enhanced.
   * It's the sad16_altivec code above w/ squaring added. */
  static int sse16_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                          int line_size, int h)
+                          ptrdiff_t stride, int h)
  {
 -    int i, s;
 +    int i;
 +    int  __attribute__((aligned(16))) s;
      const vector unsigned int zero =
          (const vector unsigned int) vec_splat_u32(0);
 -    vector unsigned char perm = vec_lvsl(0, pix2);
      vector unsigned int sum = (vector unsigned int) vec_splat_u32(0);
      vector signed int sumsqr;
  
  }
  
  static int hadamard8_diff8x8_altivec(MpegEncContext *s, uint8_t *dst,
-                                      uint8_t *src, int stride, int h)
+                                      uint8_t *src, ptrdiff_t stride, int h)
  {
 -    int sum;
 +    int __attribute__((aligned(16))) sum;
      register const vector unsigned char vzero =
          (const vector unsigned char) vec_splat_u8(0);
      register vector signed short temp0, temp1, temp2, temp3, temp4,
   * but xlc goes to around 660 on the regular C code...
   */
  static int hadamard8_diff16x8_altivec(MpegEncContext *s, uint8_t *dst,
-                                       uint8_t *src, int stride, int h)
+                                       uint8_t *src, ptrdiff_t stride, int h)
  {
 -    int sum;
 +    int __attribute__((aligned(16))) sum;
      register vector signed short
          temp0 __asm__ ("v0"),
          temp1 __asm__ ("v1"),
index 63ff7a0,0000000..5b890e0
mode 100644,000000..100644
--- /dev/null
@@@ -1,865 -1,0 +1,865 @@@
- static inline int w_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size,
 +/*
 + * Copyright (C) 2004-2010 Michael Niedermayer <michaelni@gmx.at>
 + * Copyright (C) 2008 David Conrad
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "libavutil/attributes.h"
 +#include "libavutil/avassert.h"
 +#include "libavutil/common.h"
 +#include "me_cmp.h"
 +#include "snow_dwt.h"
 +
 +int ff_slice_buffer_init(slice_buffer *buf, int line_count,
 +                         int max_allocated_lines, int line_width,
 +                         IDWTELEM *base_buffer)
 +{
 +    int i;
 +
 +    buf->base_buffer = base_buffer;
 +    buf->line_count  = line_count;
 +    buf->line_width  = line_width;
 +    buf->data_count  = max_allocated_lines;
 +    buf->line        = av_mallocz_array(line_count, sizeof(IDWTELEM *));
 +    if (!buf->line)
 +        return AVERROR(ENOMEM);
 +    buf->data_stack  = av_malloc_array(max_allocated_lines, sizeof(IDWTELEM *));
 +    if (!buf->data_stack) {
 +        av_freep(&buf->line);
 +        return AVERROR(ENOMEM);
 +    }
 +
 +    for (i = 0; i < max_allocated_lines; i++) {
 +        buf->data_stack[i] = av_malloc_array(line_width, sizeof(IDWTELEM));
 +        if (!buf->data_stack[i]) {
 +            for (i--; i >=0; i--)
 +                av_freep(&buf->data_stack[i]);
 +            av_freep(&buf->data_stack);
 +            av_freep(&buf->line);
 +            return AVERROR(ENOMEM);
 +        }
 +    }
 +
 +    buf->data_stack_top = max_allocated_lines - 1;
 +    return 0;
 +}
 +
 +IDWTELEM *ff_slice_buffer_load_line(slice_buffer *buf, int line)
 +{
 +    IDWTELEM *buffer;
 +
 +    av_assert0(buf->data_stack_top >= 0);
 +//  av_assert1(!buf->line[line]);
 +    if (buf->line[line])
 +        return buf->line[line];
 +
 +    buffer = buf->data_stack[buf->data_stack_top];
 +    buf->data_stack_top--;
 +    buf->line[line] = buffer;
 +
 +    return buffer;
 +}
 +
 +void ff_slice_buffer_release(slice_buffer *buf, int line)
 +{
 +    IDWTELEM *buffer;
 +
 +    av_assert1(line >= 0 && line < buf->line_count);
 +    av_assert1(buf->line[line]);
 +
 +    buffer = buf->line[line];
 +    buf->data_stack_top++;
 +    buf->data_stack[buf->data_stack_top] = buffer;
 +    buf->line[line]                      = NULL;
 +}
 +
 +void ff_slice_buffer_flush(slice_buffer *buf)
 +{
 +    int i;
 +    for (i = 0; i < buf->line_count; i++)
 +        if (buf->line[i])
 +            ff_slice_buffer_release(buf, i);
 +}
 +
 +void ff_slice_buffer_destroy(slice_buffer *buf)
 +{
 +    int i;
 +    ff_slice_buffer_flush(buf);
 +
 +    for (i = buf->data_count - 1; i >= 0; i--)
 +        av_freep(&buf->data_stack[i]);
 +    av_freep(&buf->data_stack);
 +    av_freep(&buf->line);
 +}
 +
 +static inline int mirror(int v, int m)
 +{
 +    while ((unsigned)v > (unsigned)m) {
 +        v = -v;
 +        if (v < 0)
 +            v += 2 * m;
 +    }
 +    return v;
 +}
 +
 +static av_always_inline void lift(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
 +                                  int dst_step, int src_step, int ref_step,
 +                                  int width, int mul, int add, int shift,
 +                                  int highpass, int inverse)
 +{
 +    const int mirror_left  = !highpass;
 +    const int mirror_right = (width & 1) ^ highpass;
 +    const int w            = (width >> 1) - 1 + (highpass & width);
 +    int i;
 +
 +#define LIFT(src, ref, inv) ((src) + ((inv) ? -(ref) : +(ref)))
 +    if (mirror_left) {
 +        dst[0] = LIFT(src[0], ((mul * 2 * ref[0] + add) >> shift), inverse);
 +        dst   += dst_step;
 +        src   += src_step;
 +    }
 +
 +    for (i = 0; i < w; i++)
 +        dst[i * dst_step] = LIFT(src[i * src_step],
 +                                 ((mul * (ref[i * ref_step] +
 +                                          ref[(i + 1) * ref_step]) +
 +                                   add) >> shift),
 +                                 inverse);
 +
 +    if (mirror_right)
 +        dst[w * dst_step] = LIFT(src[w * src_step],
 +                                 ((mul * 2 * ref[w * ref_step] + add) >> shift),
 +                                 inverse);
 +}
 +
 +static av_always_inline void liftS(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
 +                                   int dst_step, int src_step, int ref_step,
 +                                   int width, int mul, int add, int shift,
 +                                   int highpass, int inverse)
 +{
 +    const int mirror_left  = !highpass;
 +    const int mirror_right = (width & 1) ^ highpass;
 +    const int w            = (width >> 1) - 1 + (highpass & width);
 +    int i;
 +
 +    av_assert1(shift == 4);
 +#define LIFTS(src, ref, inv)                                            \
 +    ((inv) ? (src) + (((ref) + 4 * (src)) >> shift)                     \
 +           : -((-16 * (src) + (ref) + add /                             \
 +                4 + 1 + (5 << 25)) / (5 * 4) - (1 << 23)))
 +    if (mirror_left) {
 +        dst[0] = LIFTS(src[0], mul * 2 * ref[0] + add, inverse);
 +        dst   += dst_step;
 +        src   += src_step;
 +    }
 +
 +    for (i = 0; i < w; i++)
 +        dst[i * dst_step] = LIFTS(src[i * src_step],
 +                                  mul * (ref[i * ref_step] +
 +                                         ref[(i + 1) * ref_step]) + add,
 +                                  inverse);
 +
 +    if (mirror_right)
 +        dst[w * dst_step] = LIFTS(src[w * src_step],
 +                                  mul * 2 * ref[w * ref_step] + add,
 +                                  inverse);
 +}
 +
 +static void horizontal_decompose53i(DWTELEM *b, DWTELEM *temp, int width)
 +{
 +    const int width2 = width >> 1;
 +    int x;
 +    const int w2 = (width + 1) >> 1;
 +
 +    for (x = 0; x < width2; x++) {
 +        temp[x]      = b[2 * x];
 +        temp[x + w2] = b[2 * x + 1];
 +    }
 +    if (width & 1)
 +        temp[x] = b[2 * x];
 +    lift(b + w2, temp + w2, temp,   1, 1, 1, width, -1, 0, 1, 1, 0);
 +    lift(b,      temp,      b + w2, 1, 1, 1, width,  1, 2, 2, 0, 0);
 +}
 +
 +static void vertical_decompose53iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2,
 +                                    int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] -= (b0[i] + b2[i]) >> 1;
 +}
 +
 +static void vertical_decompose53iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2,
 +                                    int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] += (b0[i] + b2[i] + 2) >> 2;
 +}
 +
 +static void spatial_decompose53i(DWTELEM *buffer, DWTELEM *temp,
 +                                 int width, int height, int stride)
 +{
 +    int y;
 +    DWTELEM *b0 = buffer + mirror(-2 - 1, height - 1) * stride;
 +    DWTELEM *b1 = buffer + mirror(-2,     height - 1) * stride;
 +
 +    for (y = -2; y < height; y += 2) {
 +        DWTELEM *b2 = buffer + mirror(y + 1, height - 1) * stride;
 +        DWTELEM *b3 = buffer + mirror(y + 2, height - 1) * stride;
 +
 +        if (y + 1 < (unsigned)height)
 +            horizontal_decompose53i(b2, temp, width);
 +        if (y + 2 < (unsigned)height)
 +            horizontal_decompose53i(b3, temp, width);
 +
 +        if (y + 1 < (unsigned)height)
 +            vertical_decompose53iH0(b1, b2, b3, width);
 +        if (y + 0 < (unsigned)height)
 +            vertical_decompose53iL0(b0, b1, b2, width);
 +
 +        b0 = b2;
 +        b1 = b3;
 +    }
 +}
 +
 +static void horizontal_decompose97i(DWTELEM *b, DWTELEM *temp, int width)
 +{
 +    const int w2 = (width + 1) >> 1;
 +
 +    lift(temp + w2, b + 1, b,         1, 2, 2, width, W_AM, W_AO, W_AS, 1, 1);
 +    liftS(temp,     b,     temp + w2, 1, 2, 1, width, W_BM, W_BO, W_BS, 0, 0);
 +    lift(b + w2, temp + w2, temp,     1, 1, 1, width, W_CM, W_CO, W_CS, 1, 0);
 +    lift(b,      temp,      b + w2,   1, 1, 1, width, W_DM, W_DO, W_DS, 0, 0);
 +}
 +
 +static void vertical_decompose97iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2,
 +                                    int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] -= (W_AM * (b0[i] + b2[i]) + W_AO) >> W_AS;
 +}
 +
 +static void vertical_decompose97iH1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2,
 +                                    int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] += (W_CM * (b0[i] + b2[i]) + W_CO) >> W_CS;
 +}
 +
 +static void vertical_decompose97iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2,
 +                                    int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] = (16 * 4 * b1[i] - 4 * (b0[i] + b2[i]) + W_BO * 5 + (5 << 27)) /
 +                (5 * 16) - (1 << 23);
 +}
 +
 +static void vertical_decompose97iL1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2,
 +                                    int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] += (W_DM * (b0[i] + b2[i]) + W_DO) >> W_DS;
 +}
 +
 +static void spatial_decompose97i(DWTELEM *buffer, DWTELEM *temp,
 +                                 int width, int height, int stride)
 +{
 +    int y;
 +    DWTELEM *b0 = buffer + mirror(-4 - 1, height - 1) * stride;
 +    DWTELEM *b1 = buffer + mirror(-4,     height - 1) * stride;
 +    DWTELEM *b2 = buffer + mirror(-4 + 1, height - 1) * stride;
 +    DWTELEM *b3 = buffer + mirror(-4 + 2, height - 1) * stride;
 +
 +    for (y = -4; y < height; y += 2) {
 +        DWTELEM *b4 = buffer + mirror(y + 3, height - 1) * stride;
 +        DWTELEM *b5 = buffer + mirror(y + 4, height - 1) * stride;
 +
 +        if (y + 3 < (unsigned)height)
 +            horizontal_decompose97i(b4, temp, width);
 +        if (y + 4 < (unsigned)height)
 +            horizontal_decompose97i(b5, temp, width);
 +
 +        if (y + 3 < (unsigned)height)
 +            vertical_decompose97iH0(b3, b4, b5, width);
 +        if (y + 2 < (unsigned)height)
 +            vertical_decompose97iL0(b2, b3, b4, width);
 +        if (y + 1 < (unsigned)height)
 +            vertical_decompose97iH1(b1, b2, b3, width);
 +        if (y + 0 < (unsigned)height)
 +            vertical_decompose97iL1(b0, b1, b2, width);
 +
 +        b0 = b2;
 +        b1 = b3;
 +        b2 = b4;
 +        b3 = b5;
 +    }
 +}
 +
 +void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height,
 +                    int stride, int type, int decomposition_count)
 +{
 +    int level;
 +
 +    for (level = 0; level < decomposition_count; level++) {
 +        switch (type) {
 +        case DWT_97:
 +            spatial_decompose97i(buffer, temp,
 +                                 width >> level, height >> level,
 +                                 stride << level);
 +            break;
 +        case DWT_53:
 +            spatial_decompose53i(buffer, temp,
 +                                 width >> level, height >> level,
 +                                 stride << level);
 +            break;
 +        }
 +    }
 +}
 +
 +static void horizontal_compose53i(IDWTELEM *b, IDWTELEM *temp, int width)
 +{
 +    const int width2 = width >> 1;
 +    const int w2     = (width + 1) >> 1;
 +    int x;
 +
 +    for (x = 0; x < width2; x++) {
 +        temp[2 * x]     = b[x];
 +        temp[2 * x + 1] = b[x + w2];
 +    }
 +    if (width & 1)
 +        temp[2 * x] = b[x];
 +
 +    b[0] = temp[0] - ((temp[1] + 1) >> 1);
 +    for (x = 2; x < width - 1; x += 2) {
 +        b[x]     = temp[x]     - ((temp[x - 1] + temp[x + 1] + 2) >> 2);
 +        b[x - 1] = temp[x - 1] + ((b[x - 2]    + b[x]        + 1) >> 1);
 +    }
 +    if (width & 1) {
 +        b[x]     = temp[x]     - ((temp[x - 1]     + 1) >> 1);
 +        b[x - 1] = temp[x - 1] + ((b[x - 2] + b[x] + 1) >> 1);
 +    } else
 +        b[x - 1] = temp[x - 1] + b[x - 2];
 +}
 +
 +static void vertical_compose53iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                  int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] += (b0[i] + b2[i]) >> 1;
 +}
 +
 +static void vertical_compose53iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                  int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] -= (b0[i] + b2[i] + 2) >> 2;
 +}
 +
 +static void spatial_compose53i_buffered_init(DWTCompose *cs, slice_buffer *sb,
 +                                             int height, int stride_line)
 +{
 +    cs->b0 = slice_buffer_get_line(sb,
 +                                   mirror(-1 - 1, height - 1) * stride_line);
 +    cs->b1 = slice_buffer_get_line(sb, mirror(-1, height - 1) * stride_line);
 +    cs->y  = -1;
 +}
 +
 +static void spatial_compose53i_init(DWTCompose *cs, IDWTELEM *buffer,
 +                                    int height, int stride)
 +{
 +    cs->b0 = buffer + mirror(-1 - 1, height - 1) * stride;
 +    cs->b1 = buffer + mirror(-1,     height - 1) * stride;
 +    cs->y  = -1;
 +}
 +
 +static void spatial_compose53i_dy_buffered(DWTCompose *cs, slice_buffer *sb,
 +                                           IDWTELEM *temp,
 +                                           int width, int height,
 +                                           int stride_line)
 +{
 +    int y = cs->y;
 +
 +    IDWTELEM *b0 = cs->b0;
 +    IDWTELEM *b1 = cs->b1;
 +    IDWTELEM *b2 = slice_buffer_get_line(sb,
 +                                         mirror(y + 1, height - 1) *
 +                                         stride_line);
 +    IDWTELEM *b3 = slice_buffer_get_line(sb,
 +                                         mirror(y + 2, height - 1) *
 +                                         stride_line);
 +
 +    if (y + 1 < (unsigned)height && y < (unsigned)height) {
 +        int x;
 +
 +        for (x = 0; x < width; x++) {
 +            b2[x] -= (b1[x] + b3[x] + 2) >> 2;
 +            b1[x] += (b0[x] + b2[x])     >> 1;
 +        }
 +    } else {
 +        if (y + 1 < (unsigned)height)
 +            vertical_compose53iL0(b1, b2, b3, width);
 +        if (y + 0 < (unsigned)height)
 +            vertical_compose53iH0(b0, b1, b2, width);
 +    }
 +
 +    if (y - 1 < (unsigned)height)
 +        horizontal_compose53i(b0, temp, width);
 +    if (y + 0 < (unsigned)height)
 +        horizontal_compose53i(b1, temp, width);
 +
 +    cs->b0  = b2;
 +    cs->b1  = b3;
 +    cs->y  += 2;
 +}
 +
 +static void spatial_compose53i_dy(DWTCompose *cs, IDWTELEM *buffer,
 +                                  IDWTELEM *temp, int width, int height,
 +                                  int stride)
 +{
 +    int y        = cs->y;
 +    IDWTELEM *b0 = cs->b0;
 +    IDWTELEM *b1 = cs->b1;
 +    IDWTELEM *b2 = buffer + mirror(y + 1, height - 1) * stride;
 +    IDWTELEM *b3 = buffer + mirror(y + 2, height - 1) * stride;
 +
 +    if (y + 1 < (unsigned)height)
 +        vertical_compose53iL0(b1, b2, b3, width);
 +    if (y + 0 < (unsigned)height)
 +        vertical_compose53iH0(b0, b1, b2, width);
 +
 +    if (y - 1 < (unsigned)height)
 +        horizontal_compose53i(b0, temp, width);
 +    if (y + 0 < (unsigned)height)
 +        horizontal_compose53i(b1, temp, width);
 +
 +    cs->b0  = b2;
 +    cs->b1  = b3;
 +    cs->y  += 2;
 +}
 +
 +void ff_snow_horizontal_compose97i(IDWTELEM *b, IDWTELEM *temp, int width)
 +{
 +    const int w2 = (width + 1) >> 1;
 +    int x;
 +
 +    temp[0] = b[0] - ((3 * b[w2] + 2) >> 2);
 +    for (x = 1; x < (width >> 1); x++) {
 +        temp[2 * x]     = b[x] - ((3 * (b[x + w2 - 1] + b[x + w2]) + 4) >> 3);
 +        temp[2 * x - 1] = b[x + w2 - 1] - temp[2 * x - 2] - temp[2 * x];
 +    }
 +    if (width & 1) {
 +        temp[2 * x]     = b[x] - ((3 * b[x + w2 - 1] + 2) >> 2);
 +        temp[2 * x - 1] = b[x + w2 - 1] - temp[2 * x - 2] - temp[2 * x];
 +    } else
 +        temp[2 * x - 1] = b[x + w2 - 1] - 2 * temp[2 * x - 2];
 +
 +    b[0] = temp[0] + ((2 * temp[0] + temp[1] + 4) >> 3);
 +    for (x = 2; x < width - 1; x += 2) {
 +        b[x]     = temp[x] + ((4 * temp[x] + temp[x - 1] + temp[x + 1] + 8) >> 4);
 +        b[x - 1] = temp[x - 1] + ((3 * (b[x - 2] + b[x])) >> 1);
 +    }
 +    if (width & 1) {
 +        b[x]     = temp[x] + ((2 * temp[x] + temp[x - 1] + 4) >> 3);
 +        b[x - 1] = temp[x - 1] + ((3 * (b[x - 2] + b[x])) >> 1);
 +    } else
 +        b[x - 1] = temp[x - 1] + 3 * b[x - 2];
 +}
 +
 +static void vertical_compose97iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                  int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] += (W_AM * (b0[i] + b2[i]) + W_AO) >> W_AS;
 +}
 +
 +static void vertical_compose97iH1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                  int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] -= (W_CM * (b0[i] + b2[i]) + W_CO) >> W_CS;
 +}
 +
 +static void vertical_compose97iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                  int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] += (W_BM * (b0[i] + b2[i]) + 4 * b1[i] + W_BO) >> W_BS;
 +}
 +
 +static void vertical_compose97iL1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                  int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++)
 +        b1[i] -= (W_DM * (b0[i] + b2[i]) + W_DO) >> W_DS;
 +}
 +
 +void ff_snow_vertical_compose97i(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                 IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5,
 +                                 int width)
 +{
 +    int i;
 +
 +    for (i = 0; i < width; i++) {
 +        b4[i] -= (W_DM * (b3[i] + b5[i]) + W_DO) >> W_DS;
 +        b3[i] -= (W_CM * (b2[i] + b4[i]) + W_CO) >> W_CS;
 +        b2[i] += (W_BM * (b1[i] + b3[i]) + 4 * b2[i] + W_BO) >> W_BS;
 +        b1[i] += (W_AM * (b0[i] + b2[i]) + W_AO) >> W_AS;
 +    }
 +}
 +
 +static void spatial_compose97i_buffered_init(DWTCompose *cs, slice_buffer *sb,
 +                                             int height, int stride_line)
 +{
 +    cs->b0 = slice_buffer_get_line(sb, mirror(-3 - 1, height - 1) * stride_line);
 +    cs->b1 = slice_buffer_get_line(sb, mirror(-3,     height - 1) * stride_line);
 +    cs->b2 = slice_buffer_get_line(sb, mirror(-3 + 1, height - 1) * stride_line);
 +    cs->b3 = slice_buffer_get_line(sb, mirror(-3 + 2, height - 1) * stride_line);
 +    cs->y  = -3;
 +}
 +
 +static void spatial_compose97i_init(DWTCompose *cs, IDWTELEM *buffer, int height,
 +                                    int stride)
 +{
 +    cs->b0 = buffer + mirror(-3 - 1, height - 1) * stride;
 +    cs->b1 = buffer + mirror(-3,     height - 1) * stride;
 +    cs->b2 = buffer + mirror(-3 + 1, height - 1) * stride;
 +    cs->b3 = buffer + mirror(-3 + 2, height - 1) * stride;
 +    cs->y  = -3;
 +}
 +
 +static void spatial_compose97i_dy_buffered(SnowDWTContext *dsp, DWTCompose *cs,
 +                                           slice_buffer * sb, IDWTELEM *temp,
 +                                           int width, int height,
 +                                           int stride_line)
 +{
 +    int y = cs->y;
 +
 +    IDWTELEM *b0 = cs->b0;
 +    IDWTELEM *b1 = cs->b1;
 +    IDWTELEM *b2 = cs->b2;
 +    IDWTELEM *b3 = cs->b3;
 +    IDWTELEM *b4 = slice_buffer_get_line(sb,
 +                                         mirror(y + 3, height - 1) *
 +                                         stride_line);
 +    IDWTELEM *b5 = slice_buffer_get_line(sb,
 +                                         mirror(y + 4, height - 1) *
 +                                         stride_line);
 +
 +    if (y > 0 && y + 4 < height) {
 +        dsp->vertical_compose97i(b0, b1, b2, b3, b4, b5, width);
 +    } else {
 +        if (y + 3 < (unsigned)height)
 +            vertical_compose97iL1(b3, b4, b5, width);
 +        if (y + 2 < (unsigned)height)
 +            vertical_compose97iH1(b2, b3, b4, width);
 +        if (y + 1 < (unsigned)height)
 +            vertical_compose97iL0(b1, b2, b3, width);
 +        if (y + 0 < (unsigned)height)
 +            vertical_compose97iH0(b0, b1, b2, width);
 +    }
 +
 +    if (y - 1 < (unsigned)height)
 +        dsp->horizontal_compose97i(b0, temp, width);
 +    if (y + 0 < (unsigned)height)
 +        dsp->horizontal_compose97i(b1, temp, width);
 +
 +    cs->b0  = b2;
 +    cs->b1  = b3;
 +    cs->b2  = b4;
 +    cs->b3  = b5;
 +    cs->y  += 2;
 +}
 +
 +static void spatial_compose97i_dy(DWTCompose *cs, IDWTELEM *buffer,
 +                                  IDWTELEM *temp, int width, int height,
 +                                  int stride)
 +{
 +    int y        = cs->y;
 +    IDWTELEM *b0 = cs->b0;
 +    IDWTELEM *b1 = cs->b1;
 +    IDWTELEM *b2 = cs->b2;
 +    IDWTELEM *b3 = cs->b3;
 +    IDWTELEM *b4 = buffer + mirror(y + 3, height - 1) * stride;
 +    IDWTELEM *b5 = buffer + mirror(y + 4, height - 1) * stride;
 +
 +    if (y + 3 < (unsigned)height)
 +        vertical_compose97iL1(b3, b4, b5, width);
 +    if (y + 2 < (unsigned)height)
 +        vertical_compose97iH1(b2, b3, b4, width);
 +    if (y + 1 < (unsigned)height)
 +        vertical_compose97iL0(b1, b2, b3, width);
 +    if (y + 0 < (unsigned)height)
 +        vertical_compose97iH0(b0, b1, b2, width);
 +
 +    if (y - 1 < (unsigned)height)
 +        ff_snow_horizontal_compose97i(b0, temp, width);
 +    if (y + 0 < (unsigned)height)
 +        ff_snow_horizontal_compose97i(b1, temp, width);
 +
 +    cs->b0  = b2;
 +    cs->b1  = b3;
 +    cs->b2  = b4;
 +    cs->b3  = b5;
 +    cs->y  += 2;
 +}
 +
 +void ff_spatial_idwt_buffered_init(DWTCompose *cs, slice_buffer *sb, int width,
 +                                   int height, int stride_line, int type,
 +                                   int decomposition_count)
 +{
 +    int level;
 +    for (level = decomposition_count - 1; level >= 0; level--) {
 +        switch (type) {
 +        case DWT_97:
 +            spatial_compose97i_buffered_init(cs + level, sb, height >> level,
 +                                             stride_line << level);
 +            break;
 +        case DWT_53:
 +            spatial_compose53i_buffered_init(cs + level, sb, height >> level,
 +                                             stride_line << level);
 +            break;
 +        }
 +    }
 +}
 +
 +void ff_spatial_idwt_buffered_slice(SnowDWTContext *dsp, DWTCompose *cs,
 +                                    slice_buffer *slice_buf, IDWTELEM *temp,
 +                                    int width, int height, int stride_line,
 +                                    int type, int decomposition_count, int y)
 +{
 +    const int support = type == 1 ? 3 : 5;
 +    int level;
 +    if (type == 2)
 +        return;
 +
 +    for (level = decomposition_count - 1; level >= 0; level--)
 +        while (cs[level].y <= FFMIN((y >> level) + support, height >> level)) {
 +            switch (type) {
 +            case DWT_97:
 +                spatial_compose97i_dy_buffered(dsp, cs + level, slice_buf, temp,
 +                                               width >> level,
 +                                               height >> level,
 +                                               stride_line << level);
 +                break;
 +            case DWT_53:
 +                spatial_compose53i_dy_buffered(cs + level, slice_buf, temp,
 +                                               width >> level,
 +                                               height >> level,
 +                                               stride_line << level);
 +                break;
 +            }
 +        }
 +}
 +
 +static void ff_spatial_idwt_init(DWTCompose *cs, IDWTELEM *buffer, int width,
 +                                 int height, int stride, int type,
 +                                 int decomposition_count)
 +{
 +    int level;
 +    for (level = decomposition_count - 1; level >= 0; level--) {
 +        switch (type) {
 +        case DWT_97:
 +            spatial_compose97i_init(cs + level, buffer, height >> level,
 +                                    stride << level);
 +            break;
 +        case DWT_53:
 +            spatial_compose53i_init(cs + level, buffer, height >> level,
 +                                    stride << level);
 +            break;
 +        }
 +    }
 +}
 +
 +static void ff_spatial_idwt_slice(DWTCompose *cs, IDWTELEM *buffer,
 +                                  IDWTELEM *temp, int width, int height,
 +                                  int stride, int type,
 +                                  int decomposition_count, int y)
 +{
 +    const int support = type == 1 ? 3 : 5;
 +    int level;
 +    if (type == 2)
 +        return;
 +
 +    for (level = decomposition_count - 1; level >= 0; level--)
 +        while (cs[level].y <= FFMIN((y >> level) + support, height >> level)) {
 +            switch (type) {
 +            case DWT_97:
 +                spatial_compose97i_dy(cs + level, buffer, temp, width >> level,
 +                                      height >> level, stride << level);
 +                break;
 +            case DWT_53:
 +                spatial_compose53i_dy(cs + level, buffer, temp, width >> level,
 +                                      height >> level, stride << level);
 +                break;
 +            }
 +        }
 +}
 +
 +void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height,
 +                     int stride, int type, int decomposition_count)
 +{
 +    DWTCompose cs[MAX_DECOMPOSITIONS];
 +    int y;
 +    ff_spatial_idwt_init(cs, buffer, width, height, stride, type,
 +                         decomposition_count);
 +    for (y = 0; y < height; y += 4)
 +        ff_spatial_idwt_slice(cs, buffer, temp, width, height, stride, type,
 +                              decomposition_count, y);
 +}
 +
- static int w53_8_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
++static inline int w_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size,
 +                      int w, int h, int type)
 +{
 +    int s, i, j;
 +    const int dec_count = w == 8 ? 3 : 4;
 +    int tmp[32 * 32], tmp2[32];
 +    int level, ori;
 +    static const int scale[2][2][4][4] = {
 +        {
 +            { // 9/7 8x8 dec=3
 +                { 268, 239, 239, 213 },
 +                { 0,   224, 224, 152 },
 +                { 0,   135, 135, 110 },
 +            },
 +            { // 9/7 16x16 or 32x32 dec=4
 +                { 344, 310, 310, 280 },
 +                { 0,   320, 320, 228 },
 +                { 0,   175, 175, 136 },
 +                { 0,   129, 129, 102 },
 +            }
 +        },
 +        {
 +            { // 5/3 8x8 dec=3
 +                { 275, 245, 245, 218 },
 +                { 0,   230, 230, 156 },
 +                { 0,   138, 138, 113 },
 +            },
 +            { // 5/3 16x16 or 32x32 dec=4
 +                { 352, 317, 317, 286 },
 +                { 0,   328, 328, 233 },
 +                { 0,   180, 180, 140 },
 +                { 0,   132, 132, 105 },
 +            }
 +        }
 +    };
 +
 +    for (i = 0; i < h; i++) {
 +        for (j = 0; j < w; j += 4) {
 +            tmp[32 * i + j + 0] = (pix1[j + 0] - pix2[j + 0]) << 4;
 +            tmp[32 * i + j + 1] = (pix1[j + 1] - pix2[j + 1]) << 4;
 +            tmp[32 * i + j + 2] = (pix1[j + 2] - pix2[j + 2]) << 4;
 +            tmp[32 * i + j + 3] = (pix1[j + 3] - pix2[j + 3]) << 4;
 +        }
 +        pix1 += line_size;
 +        pix2 += line_size;
 +    }
 +
 +    ff_spatial_dwt(tmp, tmp2, w, h, 32, type, dec_count);
 +
 +    s = 0;
 +    av_assert1(w == h);
 +    for (level = 0; level < dec_count; level++)
 +        for (ori = level ? 1 : 0; ori < 4; ori++) {
 +            int size   = w >> (dec_count - level);
 +            int sx     = (ori & 1) ? size : 0;
 +            int stride = 32 << (dec_count - level);
 +            int sy     = (ori & 2) ? stride >> 1 : 0;
 +
 +            for (i = 0; i < size; i++)
 +                for (j = 0; j < size; j++) {
 +                    int v = tmp[sx + sy + i * stride + j] *
 +                            scale[type][dec_count - 3][level][ori];
 +                    s += FFABS(v);
 +                }
 +        }
 +    av_assert1(s >= 0);
 +    return s >> 9;
 +}
 +
- static int w97_8_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
++static int w53_8_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 +{
 +    return w_c(v, pix1, pix2, line_size, 8, h, 1);
 +}
 +
- static int w53_16_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
++static int w97_8_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 +{
 +    return w_c(v, pix1, pix2, line_size, 8, h, 0);
 +}
 +
- static int w97_16_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
++static int w53_16_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 +{
 +    return w_c(v, pix1, pix2, line_size, 16, h, 1);
 +}
 +
- int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
++static int w97_16_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 +{
 +    return w_c(v, pix1, pix2, line_size, 16, h, 0);
 +}
 +
- int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
++int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 +{
 +    return w_c(v, pix1, pix2, line_size, 32, h, 1);
 +}
 +
++int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 +{
 +    return w_c(v, pix1, pix2, line_size, 32, h, 0);
 +}
 +
 +void ff_dsputil_init_dwt(MECmpContext *c)
 +{
 +    c->w53[0] = w53_16_c;
 +    c->w53[1] = w53_8_c;
 +    c->w97[0] = w97_16_c;
 +    c->w97[1] = w97_8_c;
 +}
 +
 +void ff_dwt_init(SnowDWTContext *c)
 +{
 +    c->vertical_compose97i   = ff_snow_vertical_compose97i;
 +    c->horizontal_compose97i = ff_snow_horizontal_compose97i;
 +    c->inner_add_yblock      = ff_snow_inner_add_yblock;
 +
 +    if (HAVE_MMX)
 +        ff_dwt_init_x86(c);
 +}
 +
 +
index e929189,0000000..6ac49e2
mode 100644,000000..100644
--- /dev/null
@@@ -1,127 -1,0 +1,127 @@@
- int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);
- int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);
 +/*
 + * Copyright (C) 2004-2010 Michael Niedermayer <michaelni@gmx.at>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#ifndef AVCODEC_SNOW_DWT_H
 +#define AVCODEC_SNOW_DWT_H
 +
 +#include <stdint.h>
 +
 +typedef int DWTELEM;
 +typedef short IDWTELEM;
 +
 +#define MAX_DECOMPOSITIONS 8
 +
 +typedef struct DWTCompose {
 +    IDWTELEM *b0;
 +    IDWTELEM *b1;
 +    IDWTELEM *b2;
 +    IDWTELEM *b3;
 +    int y;
 +} DWTCompose;
 +
 +/** Used to minimize the amount of memory used in order to
 + *  optimize cache performance. **/
 +typedef struct slice_buffer_s {
 +    IDWTELEM **line;   ///< For use by idwt and predict_slices.
 +    IDWTELEM **data_stack;   ///< Used for internal purposes.
 +    int data_stack_top;
 +    int line_count;
 +    int line_width;
 +    int data_count;
 +    IDWTELEM *base_buffer;  ///< Buffer that this structure is caching.
 +} slice_buffer;
 +
 +struct SnowDWTContext;
 +
 +typedef struct SnowDWTContext {
 +    void (*vertical_compose97i)(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5,
 +                                int width);
 +    void (*horizontal_compose97i)(IDWTELEM *b, IDWTELEM *temp, int width);
 +    void (*inner_add_yblock)(const uint8_t *obmc, const int obmc_stride,
 +                             uint8_t **block, int b_w, int b_h, int src_x,
 +                             int src_y, int src_stride, slice_buffer *sb,
 +                             int add, uint8_t *dst8);
 +} SnowDWTContext;
 +
 +
 +#define DWT_97 0
 +#define DWT_53 1
 +
 +#define liftS lift
 +#define W_AM 3
 +#define W_AO 0
 +#define W_AS 1
 +
 +#undef liftS
 +#define W_BM 1
 +#define W_BO 8
 +#define W_BS 4
 +
 +#define W_CM 1
 +#define W_CO 0
 +#define W_CS 0
 +
 +#define W_DM 3
 +#define W_DO 4
 +#define W_DS 3
 +
 +#define slice_buffer_get_line(slice_buf, line_num)                          \
 +    ((slice_buf)->line[line_num] ? (slice_buf)->line[line_num]              \
 +                                 : ff_slice_buffer_load_line((slice_buf),   \
 +                                                             (line_num)))
 +
 +int ff_slice_buffer_init(slice_buffer *buf, int line_count,
 +                         int max_allocated_lines, int line_width,
 +                         IDWTELEM *base_buffer);
 +void ff_slice_buffer_release(slice_buffer *buf, int line);
 +void ff_slice_buffer_flush(slice_buffer *buf);
 +void ff_slice_buffer_destroy(slice_buffer *buf);
 +IDWTELEM *ff_slice_buffer_load_line(slice_buffer *buf, int line);
 +
 +void ff_snow_vertical_compose97i(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2,
 +                                 IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5,
 +                                 int width);
 +void ff_snow_horizontal_compose97i(IDWTELEM *b, IDWTELEM *temp, int width);
 +void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride,
 +                              uint8_t **block, int b_w, int b_h, int src_x,
 +                              int src_y, int src_stride, slice_buffer *sb,
 +                              int add, uint8_t *dst8);
 +
++int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h);
++int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h);
 +
 +void ff_spatial_dwt(int *buffer, int *temp, int width, int height, int stride,
 +                    int type, int decomposition_count);
 +
 +void ff_spatial_idwt_buffered_init(DWTCompose *cs, slice_buffer *sb, int width,
 +                                   int height, int stride_line, int type,
 +                                   int decomposition_count);
 +void ff_spatial_idwt_buffered_slice(SnowDWTContext *dsp, DWTCompose *cs,
 +                                    slice_buffer *slice_buf, IDWTELEM *temp,
 +                                    int width, int height, int stride_line,
 +                                    int type, int decomposition_count, int y);
 +void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height,
 +                     int stride, int type, int decomposition_count);
 +
 +void ff_dwt_init(SnowDWTContext *c);
 +void ff_dwt_init_x86(SnowDWTContext *c);
 +
 +#endif /* AVCODEC_DWT_H */
@@@ -215,7 -210,7 +215,7 @@@ hadamard8_16_wrapper %1, 
  %elif cpuflag(mmx)
  ALIGN 16
  ; int ff_hadamard8_diff_ ## cpu(MpegEncContext *s, uint8_t *src1,
--;                               uint8_t *src2, int stride, int h)
++;                               uint8_t *src2, ptrdiff_t stride, int h)
  ; r0 = void *s = unused, int h = unused (always 8)
  ; note how r1, r2 and r3 are not clobbered in this function, so 16x16
  ; can simply call this 2x2x (and that's why we access rsp+gprsize
@@@ -279,14 -274,11 +279,14 @@@ INIT_XMM ssse
  %define ABS_SUM_8x8 ABS_SUM_8x8_64
  HADAMARD8_DIFF 9
  
 -INIT_XMM sse2
 -; int ff_sse16_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 -;                   int line_size, int h);
 -cglobal sse16, 5, 5, 8
 -    shr      r4d, 1
 +; int ff_sse*_*(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
- ;               int line_size, int h)
++;               ptrdiff_t line_size, int h)
 +
 +%macro SUM_SQUARED_ERRORS 1
 +cglobal sse%1, 5,5,8, v, pix1, pix2, lsize, h
 +%if %1 == mmsize
 +    shr       hd, 1
 +%endif
      pxor      m0, m0         ; mm0 = 0
      pxor      m7, m7         ; mm7 holds the sum
  
      paddd     m7, m1
      paddd     m7, m3
  
 -    dec       r4
 +%if %1 == mmsize
 +    lea    pix1q, [pix1q + 2*lsizeq]
 +    lea    pix2q, [pix2q + 2*lsizeq]
 +%else
 +    add    pix1q, lsizeq
 +    add    pix2q, lsizeq
 +%endif
 +    dec       hd
      jnz .next2lines
  
 -    mova      m1, m7
 -    psrldq    m7, 8          ; shift hi qword to lo
 -    paddd     m7, m1
 -    mova      m1, m7
 -    psrldq    m7, 4          ; shift hi dword to lo
 -    paddd     m7, m1
 +    HADDD     m7, m1
      movd     eax, m7         ; return value
      RET
- ; int ff_hf_noise*_mmx(uint8_t *pix1, int lsize, int h)
 +%endmacro
 +
 +INIT_MMX mmx
 +SUM_SQUARED_ERRORS 8
 +
 +INIT_MMX mmx
 +SUM_SQUARED_ERRORS 16
 +
 +INIT_XMM sse2
 +SUM_SQUARED_ERRORS 16
 +
 +;-----------------------------------------------
 +;int ff_sum_abs_dctelem(int16_t *block)
 +;-----------------------------------------------
 +; %1 = number of xmm registers used
 +; %2 = number of inline loops
 +
 +%macro SUM_ABS_DCTELEM 2
 +cglobal sum_abs_dctelem, 1, 1, %1, block
 +    pxor    m0, m0
 +    pxor    m1, m1
 +%assign %%i 0
 +%rep %2
 +    mova      m2, [blockq+mmsize*(0+%%i)]
 +    mova      m3, [blockq+mmsize*(1+%%i)]
 +    mova      m4, [blockq+mmsize*(2+%%i)]
 +    mova      m5, [blockq+mmsize*(3+%%i)]
 +    ABS1_SUM  m2, m6, m0
 +    ABS1_SUM  m3, m6, m1
 +    ABS1_SUM  m4, m6, m0
 +    ABS1_SUM  m5, m6, m1
 +%assign %%i %%i+4
 +%endrep
 +    paddusw m0, m1
 +    HSUM    m0, m1, eax
 +    and     eax, 0xFFFF
 +    RET
 +%endmacro
 +
 +INIT_MMX mmx
 +SUM_ABS_DCTELEM 0, 4
 +INIT_MMX mmxext
 +SUM_ABS_DCTELEM 0, 4
 +INIT_XMM sse2
 +SUM_ABS_DCTELEM 7, 2
 +INIT_XMM ssse3
 +SUM_ABS_DCTELEM 6, 2
 +
 +;------------------------------------------------------------------------------
-     movsxdifnidn lsizeq, lsized
++; int ff_hf_noise*_mmx(uint8_t *pix1, ptrdiff_t lsize, int h)
 +;------------------------------------------------------------------------------
 +; %1 = 8/16. %2-5=m#
 +%macro HF_NOISE_PART1 5
 +    mova      m%2, [pix1q]
 +%if %1 == 8
 +    mova      m%3, m%2
 +    psllq     m%2, 8
 +    psrlq     m%3, 8
 +    psrlq     m%2, 8
 +%else
 +    mova      m%3, [pix1q+1]
 +%endif
 +    mova      m%4, m%2
 +    mova      m%5, m%3
 +    punpcklbw m%2, m7
 +    punpcklbw m%3, m7
 +    punpckhbw m%4, m7
 +    punpckhbw m%5, m7
 +    psubw     m%2, m%3
 +    psubw     m%4, m%5
 +%endmacro
 +
 +; %1-2 = m#
 +%macro HF_NOISE_PART2 4
 +    psubw     m%1, m%3
 +    psubw     m%2, m%4
 +    pxor       m3, m3
 +    pxor       m1, m1
 +    pcmpgtw    m3, m%1
 +    pcmpgtw    m1, m%2
 +    pxor      m%1, m3
 +    pxor      m%2, m1
 +    psubw     m%1, m3
 +    psubw     m%2, m1
 +    paddw     m%2, m%1
 +    paddw      m6, m%2
 +%endmacro
 +
 +; %1 = 8/16
 +%macro HF_NOISE 1
 +cglobal hf_noise%1, 3,3,0, pix1, lsize, h
- ;int ff_sad_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int stride, int h);
 +    sub        hd, 2
 +    pxor       m7, m7
 +    pxor       m6, m6
 +    HF_NOISE_PART1 %1, 0, 1, 2, 3
 +    add     pix1q, lsizeq
 +    HF_NOISE_PART1 %1, 4, 1, 5, 3
 +    HF_NOISE_PART2     0, 2, 4, 5
 +    add     pix1q, lsizeq
 +.loop:
 +    HF_NOISE_PART1 %1, 0, 1, 2, 3
 +    HF_NOISE_PART2     4, 5, 0, 2
 +    add     pix1q, lsizeq
 +    HF_NOISE_PART1 %1, 4, 1, 5, 3
 +    HF_NOISE_PART2     0, 2, 4, 5
 +    add     pix1q, lsizeq
 +    sub        hd, 2
 +        jne .loop
 +
 +    mova       m0, m6
 +    punpcklwd  m0, m7
 +    punpckhwd  m6, m7
 +    paddd      m6, m0
 +    mova       m0, m6
 +    psrlq      m6, 32
 +    paddd      m0, m6
 +    movd      eax, m0   ; eax = result of hf_noise8;
 +    REP_RET                 ; return eax;
 +%endmacro
 +
 +INIT_MMX mmx
 +HF_NOISE 8
 +HF_NOISE 16
 +
 +;---------------------------------------------------------------------------------------
- ;int ff_sad_x2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int stride, int h);
++;int ff_sad_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
 +;---------------------------------------------------------------------------------------
 +;%1 = 8/16
 +%macro SAD 1
 +cglobal sad%1, 5, 5, 3, v, pix1, pix2, stride, h
 +    movu      m2, [pix2q]
 +    movu      m1, [pix2q+strideq]
 +    psadbw    m2, [pix1q]
 +    psadbw    m1, [pix1q+strideq]
 +    paddw     m2, m1
 +%if %1 != mmsize
 +    movu      m0, [pix2q+8]
 +    movu      m1, [pix2q+strideq+8]
 +    psadbw    m0, [pix1q+8]
 +    psadbw    m1, [pix1q+strideq+8]
 +    paddw     m2, m0
 +    paddw     m2, m1
 +%endif
 +    sub       hd, 2
 +
 +align 16
 +.loop:
 +    lea    pix1q, [pix1q+strideq*2]
 +    lea    pix2q, [pix2q+strideq*2]
 +    movu      m0, [pix2q]
 +    movu      m1, [pix2q+strideq]
 +    psadbw    m0, [pix1q]
 +    psadbw    m1, [pix1q+strideq]
 +    paddw     m2, m0
 +    paddw     m2, m1
 +%if %1 != mmsize
 +    movu      m0, [pix2q+8]
 +    movu      m1, [pix2q+strideq+8]
 +    psadbw    m0, [pix1q+8]
 +    psadbw    m1, [pix1q+strideq+8]
 +    paddw     m2, m0
 +    paddw     m2, m1
 +%endif
 +    sub       hd, 2
 +    jg .loop
 +%if mmsize == 16
 +    movhlps   m0, m2
 +    paddw     m2, m0
 +%endif
 +    movd     eax, m2
 +    RET
 +%endmacro
 +
 +INIT_MMX mmxext
 +SAD 8
 +SAD 16
 +INIT_XMM sse2
 +SAD 16
 +
 +;------------------------------------------------------------------------------------------
- ;int ff_sad_y2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int stride, int h);
++;int ff_sad_x2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
 +;------------------------------------------------------------------------------------------
 +;%1 = 8/16
 +%macro SAD_X2 1
 +cglobal sad%1_x2, 5, 5, 5, v, pix1, pix2, stride, h
 +    movu      m0, [pix2q]
 +    movu      m2, [pix2q+strideq]
 +%if mmsize == 16
 +    movu      m3, [pix2q+1]
 +    movu      m4, [pix2q+strideq+1]
 +    pavgb     m0, m3
 +    pavgb     m2, m4
 +%else
 +    pavgb     m0, [pix2q+1]
 +    pavgb     m2, [pix2q+strideq+1]
 +%endif
 +    psadbw    m0, [pix1q]
 +    psadbw    m2, [pix1q+strideq]
 +    paddw     m0, m2
 +%if %1 != mmsize
 +    movu      m1, [pix2q+8]
 +    movu      m2, [pix2q+strideq+8]
 +    pavgb     m1, [pix2q+9]
 +    pavgb     m2, [pix2q+strideq+9]
 +    psadbw    m1, [pix1q+8]
 +    psadbw    m2, [pix1q+strideq+8]
 +    paddw     m0, m1
 +    paddw     m0, m2
 +%endif
 +    sub       hd, 2
 +
 +align 16
 +.loop:
 +    lea    pix1q, [pix1q+2*strideq]
 +    lea    pix2q, [pix2q+2*strideq]
 +    movu      m1, [pix2q]
 +    movu      m2, [pix2q+strideq]
 +%if mmsize == 16
 +    movu      m3, [pix2q+1]
 +    movu      m4, [pix2q+strideq+1]
 +    pavgb     m1, m3
 +    pavgb     m2, m4
 +%else
 +    pavgb     m1, [pix2q+1]
 +    pavgb     m2, [pix2q+strideq+1]
 +%endif
 +    psadbw    m1, [pix1q]
 +    psadbw    m2, [pix1q+strideq]
 +    paddw     m0, m1
 +    paddw     m0, m2
 +%if %1 != mmsize
 +    movu      m1, [pix2q+8]
 +    movu      m2, [pix2q+strideq+8]
 +    pavgb     m1, [pix2q+9]
 +    pavgb     m2, [pix2q+strideq+9]
 +    psadbw    m1, [pix1q+8]
 +    psadbw    m2, [pix1q+strideq+8]
 +    paddw     m0, m1
 +    paddw     m0, m2
 +%endif
 +    sub       hd, 2
 +    jg .loop
 +%if mmsize == 16
 +    movhlps   m1, m0
 +    paddw     m0, m1
 +%endif
 +    movd     eax, m0
 +    RET
 +%endmacro
 +
 +INIT_MMX mmxext
 +SAD_X2 8
 +SAD_X2 16
 +INIT_XMM sse2
 +SAD_X2 16
 +
 +;------------------------------------------------------------------------------------------
- ;int ff_sad_approx_xy2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int stride, int h);
++;int ff_sad_y2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
 +;------------------------------------------------------------------------------------------
 +;%1 = 8/16
 +%macro SAD_Y2 1
 +cglobal sad%1_y2, 5, 5, 4, v, pix1, pix2, stride, h
 +    movu      m1, [pix2q]
 +    movu      m0, [pix2q+strideq]
 +    movu      m3, [pix2q+2*strideq]
 +    pavgb     m1, m0
 +    pavgb     m0, m3
 +    psadbw    m1, [pix1q]
 +    psadbw    m0, [pix1q+strideq]
 +    paddw     m0, m1
 +    mova      m1, m3
 +%if %1 != mmsize
 +    movu      m4, [pix2q+8]
 +    movu      m5, [pix2q+strideq+8]
 +    movu      m6, [pix2q+2*strideq+8]
 +    pavgb     m4, m5
 +    pavgb     m5, m6
 +    psadbw    m4, [pix1q+8]
 +    psadbw    m5, [pix1q+strideq+8]
 +    paddw     m0, m4
 +    paddw     m0, m5
 +    mova      m4, m6
 +%endif
 +    add    pix2q, strideq
 +    sub       hd, 2
 +
 +align 16
 +.loop:
 +    lea    pix1q, [pix1q+2*strideq]
 +    lea    pix2q, [pix2q+2*strideq]
 +    movu      m2, [pix2q]
 +    movu      m3, [pix2q+strideq]
 +    pavgb     m1, m2
 +    pavgb     m2, m3
 +    psadbw    m1, [pix1q]
 +    psadbw    m2, [pix1q+strideq]
 +    paddw     m0, m1
 +    paddw     m0, m2
 +    mova      m1, m3
 +%if %1 != mmsize
 +    movu      m5, [pix2q+8]
 +    movu      m6, [pix2q+strideq+8]
 +    pavgb     m4, m5
 +    pavgb     m5, m6
 +    psadbw    m4, [pix1q+8]
 +    psadbw    m5, [pix1q+strideq+8]
 +    paddw     m0, m4
 +    paddw     m0, m5
 +    mova      m4, m6
 +%endif
 +    sub       hd, 2
 +    jg .loop
 +%if mmsize == 16
 +    movhlps   m1, m0
 +    paddw     m0, m1
 +%endif
 +    movd     eax, m0
 +    RET
 +%endmacro
 +
 +INIT_MMX mmxext
 +SAD_Y2 8
 +SAD_Y2 16
 +INIT_XMM sse2
 +SAD_Y2 16
 +
 +;-------------------------------------------------------------------------------------------
- ;                  int line_size, int h);
++;int ff_sad_approx_xy2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
 +;-------------------------------------------------------------------------------------------
 +;%1 = 8/16
 +%macro SAD_APPROX_XY2 1
 +cglobal sad%1_approx_xy2, 5, 5, 7, v, pix1, pix2, stride, h
 +    mova      m4, [pb_1]
 +    movu      m1, [pix2q]
 +    movu      m0, [pix2q+strideq]
 +    movu      m3, [pix2q+2*strideq]
 +%if mmsize == 16
 +    movu      m5, [pix2q+1]
 +    movu      m6, [pix2q+strideq+1]
 +    movu      m2, [pix2q+2*strideq+1]
 +    pavgb     m1, m5
 +    pavgb     m0, m6
 +    pavgb     m3, m2
 +%else
 +    pavgb     m1, [pix2q+1]
 +    pavgb     m0, [pix2q+strideq+1]
 +    pavgb     m3, [pix2q+2*strideq+1]
 +%endif
 +    psubusb   m0, m4
 +    pavgb     m1, m0
 +    pavgb     m0, m3
 +    psadbw    m1, [pix1q]
 +    psadbw    m0, [pix1q+strideq]
 +    paddw     m0, m1
 +    mova      m1, m3
 +%if %1 != mmsize
 +    movu      m5, [pix2q+8]
 +    movu      m6, [pix2q+strideq+8]
 +    movu      m7, [pix2q+2*strideq+8]
 +    pavgb     m5, [pix2q+1+8]
 +    pavgb     m6, [pix2q+strideq+1+8]
 +    pavgb     m7, [pix2q+2*strideq+1+8]
 +    psubusb   m6, m4
 +    pavgb     m5, m6
 +    pavgb     m6, m7
 +    psadbw    m5, [pix1q+8]
 +    psadbw    m6, [pix1q+strideq+8]
 +    paddw     m0, m5
 +    paddw     m0, m6
 +    mova      m5, m7
 +%endif
 +    add    pix2q, strideq
 +    sub       hd, 2
 +
 +align 16
 +.loop:
 +    lea    pix1q, [pix1q+2*strideq]
 +    lea    pix2q, [pix2q+2*strideq]
 +    movu      m2, [pix2q]
 +    movu      m3, [pix2q+strideq]
 +%if mmsize == 16
 +    movu      m5, [pix2q+1]
 +    movu      m6, [pix2q+strideq+1]
 +    pavgb     m2, m5
 +    pavgb     m3, m6
 +%else
 +    pavgb     m2, [pix2q+1]
 +    pavgb     m3, [pix2q+strideq+1]
 +%endif
 +    psubusb   m2, m4
 +    pavgb     m1, m2
 +    pavgb     m2, m3
 +    psadbw    m1, [pix1q]
 +    psadbw    m2, [pix1q+strideq]
 +    paddw     m0, m1
 +    paddw     m0, m2
 +    mova      m1, m3
 +%if %1 != mmsize
 +    movu      m6, [pix2q+8]
 +    movu      m7, [pix2q+strideq+8]
 +    pavgb     m6, [pix2q+8+1]
 +    pavgb     m7, [pix2q+strideq+8+1]
 +    psubusb   m6, m4
 +    pavgb     m5, m6
 +    pavgb     m6, m7
 +    psadbw    m5, [pix1q+8]
 +    psadbw    m6, [pix1q+strideq+8]
 +    paddw     m0, m5
 +    paddw     m0, m6
 +    mova      m5, m7
 +%endif
 +    sub       hd, 2
 +    jg .loop
 +%if mmsize == 16
 +    movhlps   m1, m0
 +    paddw     m0, m1
 +%endif
 +    movd     eax, m0
 +    RET
 +%endmacro
 +
 +INIT_MMX mmxext
 +SAD_APPROX_XY2 8
 +SAD_APPROX_XY2 16
 +INIT_XMM sse2
 +SAD_APPROX_XY2 16
 +
 +;--------------------------------------------------------------------
 +;int ff_vsad_intra(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
- ;                   int line_size, int h);
++;                  ptrdiff_t line_size, int h);
 +;--------------------------------------------------------------------
 +; %1 = 8/16
 +%macro VSAD_INTRA 1
 +cglobal vsad_intra%1, 5, 5, 3, v, pix1, pix2, lsize, h
 +    mova      m0, [pix1q]
 +%if %1 == mmsize
 +    mova      m2, [pix1q+lsizeq]
 +    psadbw    m0, m2
 +%else
 +    mova      m2, [pix1q+lsizeq]
 +    mova      m3, [pix1q+8]
 +    mova      m4, [pix1q+lsizeq+8]
 +    psadbw    m0, m2
 +    psadbw    m3, m4
 +    paddw     m0, m3
 +%endif
 +    sub       hd, 2
 +
 +.loop
 +    lea    pix1q, [pix1q + 2*lsizeq]
 +%if %1 == mmsize
 +    mova      m1, [pix1q]
 +    psadbw    m2, m1
 +    paddw     m0, m2
 +    mova      m2, [pix1q+lsizeq]
 +    psadbw    m1, m2
 +    paddw     m0, m1
 +%else
 +    mova      m1, [pix1q]
 +    mova      m3, [pix1q+8]
 +    psadbw    m2, m1
 +    psadbw    m4, m3
 +    paddw     m0, m2
 +    paddw     m0, m4
 +    mova      m2, [pix1q+lsizeq]
 +    mova      m4, [pix1q+lsizeq+8]
 +    psadbw    m1, m2
 +    psadbw    m3, m4
 +    paddw     m0, m1
 +    paddw     m0, m3
 +%endif
 +    sub       hd, 2
 +    jg     .loop
 +
 +%if mmsize == 16
 +    pshufd m1, m0, 0xe
 +    paddd  m0, m1
 +%endif
 +    movd eax, m0
 +    RET
 +%endmacro
 +
 +INIT_MMX mmxext
 +VSAD_INTRA 8
 +VSAD_INTRA 16
 +INIT_XMM sse2
 +VSAD_INTRA 16
 +
 +;---------------------------------------------------------------------
 +;int ff_vsad_approx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
++;                   ptrdiff_t line_size, int h);
 +;---------------------------------------------------------------------
 +; %1 = 8/16
 +%macro VSAD_APPROX 1
 +cglobal vsad%1_approx, 5, 5, 5, v, pix1, pix2, lsize, h
 +    mova   m1, [pb_80]
 +    mova   m0, [pix1q]
 +%if %1 == mmsize ; vsad8_mmxext, vsad16_sse2
 +    mova   m4, [pix1q+lsizeq]
 +%if mmsize == 16
 +    movu   m3, [pix2q]
 +    movu   m2, [pix2q+lsizeq]
 +    psubb  m0, m3
 +    psubb  m4, m2
 +%else
 +    psubb  m0, [pix2q]
 +    psubb  m4, [pix2q+lsizeq]
 +%endif
 +    pxor   m0, m1
 +    pxor   m4, m1
 +    psadbw m0, m4
 +%else ; vsad16_mmxext
 +    mova   m3, [pix1q+8]
 +    psubb  m0, [pix2q]
 +    psubb  m3, [pix2q+8]
 +    pxor   m0, m1
 +    pxor   m3, m1
 +    mova   m4, [pix1q+lsizeq]
 +    mova   m5, [pix1q+lsizeq+8]
 +    psubb  m4, [pix2q+lsizeq]
 +    psubb  m5, [pix2q+lsizeq+8]
 +    pxor   m4, m1
 +    pxor   m5, m1
 +    psadbw m0, m4
 +    psadbw m3, m5
 +    paddw  m0, m3
 +%endif
 +    sub    hd, 2
 +
 +.loop
 +    lea pix1q, [pix1q + 2*lsizeq]
 +    lea pix2q, [pix2q + 2*lsizeq]
 +    mova   m2, [pix1q]
 +%if %1 == mmsize ; vsad8_mmxext, vsad16_sse2
 +%if mmsize == 16
 +    movu   m3, [pix2q]
 +    psubb  m2, m3
 +%else
 +    psubb  m2, [pix2q]
 +%endif
 +    pxor   m2, m1
 +    psadbw m4, m2
 +    paddw  m0, m4
 +    mova   m4, [pix1q+lsizeq]
 +    movu   m3, [pix2q+lsizeq]
 +    psubb  m4, m3
 +    pxor   m4, m1
 +    psadbw m2, m4
 +    paddw  m0, m2
 +%else ; vsad16_mmxext
 +    mova   m3, [pix1q+8]
 +    psubb  m2, [pix2q]
 +    psubb  m3, [pix2q+8]
 +    pxor   m2, m1
 +    pxor   m3, m1
 +    psadbw m4, m2
 +    psadbw m5, m3
 +    paddw  m0, m4
 +    paddw  m0, m5
 +    mova   m4, [pix1q+lsizeq]
 +    mova   m5, [pix1q+lsizeq+8]
 +    psubb  m4, [pix2q+lsizeq]
 +    psubb  m5, [pix2q+lsizeq+8]
 +    pxor   m4, m1
 +    pxor   m5, m1
 +    psadbw m2, m4
 +    psadbw m3, m5
 +    paddw  m0, m2
 +    paddw  m0, m3
 +%endif
 +    sub    hd, 2
 +    jg  .loop
 +
 +%if mmsize == 16
 +    pshufd m1, m0, 0xe
 +    paddd  m0, m1
 +%endif
 +    movd  eax, m0
 +    RET
 +%endmacro
 +
 +INIT_MMX mmxext
 +VSAD_APPROX 8
 +VSAD_APPROX 16
 +INIT_XMM sse2
 +VSAD_APPROX 16
  #include "libavcodec/me_cmp.h"
  #include "libavcodec/mpegvideo.h"
  
 -#if HAVE_INLINE_ASM
 -
 -static int sse8_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 -                    ptrdiff_t stride, int h)
 -{
 -    int tmp;
 -
 -    __asm__ volatile (
 -        "movl         %4, %%ecx          \n"
 -        "shr          $1, %%ecx          \n"
 -        "pxor      %%mm0, %%mm0          \n" /* mm0 = 0 */
 -        "pxor      %%mm7, %%mm7          \n" /* mm7 holds the sum */
 -        "1:                              \n"
 -        "movq       (%0), %%mm1          \n" /* mm1 = pix1[0][0 - 7] */
 -        "movq       (%1), %%mm2          \n" /* mm2 = pix2[0][0 - 7] */
 -        "movq   (%0, %3), %%mm3          \n" /* mm3 = pix1[1][0 - 7] */
 -        "movq   (%1, %3), %%mm4          \n" /* mm4 = pix2[1][0 - 7] */
 -
 -        /* todo: mm1-mm2, mm3-mm4 */
 -        /* algo: subtract mm1 from mm2 with saturation and vice versa */
 -        /*       OR the results to get absolute difference */
 -        "movq      %%mm1, %%mm5          \n"
 -        "movq      %%mm3, %%mm6          \n"
 -        "psubusb   %%mm2, %%mm1          \n"
 -        "psubusb   %%mm4, %%mm3          \n"
 -        "psubusb   %%mm5, %%mm2          \n"
 -        "psubusb   %%mm6, %%mm4          \n"
 -
 -        "por       %%mm1, %%mm2          \n"
 -        "por       %%mm3, %%mm4          \n"
 -
 -        /* now convert to 16-bit vectors so we can square them */
 -        "movq      %%mm2, %%mm1          \n"
 -        "movq      %%mm4, %%mm3          \n"
 -
 -        "punpckhbw %%mm0, %%mm2          \n"
 -        "punpckhbw %%mm0, %%mm4          \n"
 -        "punpcklbw %%mm0, %%mm1          \n" /* mm1 now spread over (mm1, mm2) */
 -        "punpcklbw %%mm0, %%mm3          \n" /* mm4 now spread over (mm3, mm4) */
 -
 -        "pmaddwd   %%mm2, %%mm2          \n"
 -        "pmaddwd   %%mm4, %%mm4          \n"
 -        "pmaddwd   %%mm1, %%mm1          \n"
 -        "pmaddwd   %%mm3, %%mm3          \n"
 -
 -        "lea (%0, %3, 2), %0             \n" /* pix1 += 2 * stride */
 -        "lea (%1, %3, 2), %1             \n" /* pix2 += 2 * stride */
 -
 -        "paddd     %%mm2, %%mm1          \n"
 -        "paddd     %%mm4, %%mm3          \n"
 -        "paddd     %%mm1, %%mm7          \n"
 -        "paddd     %%mm3, %%mm7          \n"
 -
 -        "decl      %%ecx                 \n"
 -        "jnz       1b                    \n"
 -
 -        "movq      %%mm7, %%mm1          \n"
 -        "psrlq       $32, %%mm7          \n" /* shift hi dword to lo */
 -        "paddd     %%mm7, %%mm1          \n"
 -        "movd      %%mm1, %2             \n"
 -        : "+r" (pix1), "+r" (pix2), "=r" (tmp)
 -        : "r" (stride), "m" (h)
 -        : "%ecx");
 -
 -    return tmp;
 -}
 -
 -static int sse16_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 -                     ptrdiff_t stride, int h)
 -{
 -    int tmp;
 -
 -    __asm__ volatile (
 -        "movl %4, %%ecx\n"
 -        "pxor %%mm0, %%mm0\n"    /* mm0 = 0 */
 -        "pxor %%mm7, %%mm7\n"    /* mm7 holds the sum */
 -        "1:\n"
 -        "movq (%0), %%mm1\n"     /* mm1 = pix1[0 -  7] */
 -        "movq (%1), %%mm2\n"     /* mm2 = pix2[0 -  7] */
 -        "movq 8(%0), %%mm3\n"    /* mm3 = pix1[8 - 15] */
 -        "movq 8(%1), %%mm4\n"    /* mm4 = pix2[8 - 15] */
 -
 -        /* todo: mm1-mm2, mm3-mm4 */
 -        /* algo: subtract mm1 from mm2 with saturation and vice versa */
 -        /*       OR the results to get absolute difference */
 -        "movq %%mm1, %%mm5\n"
 -        "movq %%mm3, %%mm6\n"
 -        "psubusb %%mm2, %%mm1\n"
 -        "psubusb %%mm4, %%mm3\n"
 -        "psubusb %%mm5, %%mm2\n"
 -        "psubusb %%mm6, %%mm4\n"
 -
 -        "por %%mm1, %%mm2\n"
 -        "por %%mm3, %%mm4\n"
 -
 -        /* now convert to 16-bit vectors so we can square them */
 -        "movq %%mm2, %%mm1\n"
 -        "movq %%mm4, %%mm3\n"
 -
 -        "punpckhbw %%mm0, %%mm2\n"
 -        "punpckhbw %%mm0, %%mm4\n"
 -        "punpcklbw %%mm0, %%mm1\n" /* mm1 now spread over (mm1, mm2) */
 -        "punpcklbw %%mm0, %%mm3\n" /* mm4 now spread over (mm3, mm4) */
 -
 -        "pmaddwd %%mm2, %%mm2\n"
 -        "pmaddwd %%mm4, %%mm4\n"
 -        "pmaddwd %%mm1, %%mm1\n"
 -        "pmaddwd %%mm3, %%mm3\n"
 -
 -        "add %3, %0\n"
 -        "add %3, %1\n"
 -
 -        "paddd %%mm2, %%mm1\n"
 -        "paddd %%mm4, %%mm3\n"
 -        "paddd %%mm1, %%mm7\n"
 -        "paddd %%mm3, %%mm7\n"
 -
 -        "decl %%ecx\n"
 -        "jnz 1b\n"
 -
 -        "movq %%mm7, %%mm1\n"
 -        "psrlq $32, %%mm7\n"    /* shift hi dword to lo */
 -        "paddd %%mm7, %%mm1\n"
 -        "movd %%mm1, %2\n"
 -        : "+r" (pix1), "+r" (pix2), "=r" (tmp)
 -        : "r" (stride), "m" (h)
 -        : "%ecx");
 -
 -    return tmp;
 -}
 -
 -static int hf_noise8_mmx(uint8_t *pix1, ptrdiff_t stride, int h)
 -{
 -    int tmp;
 -
 -    __asm__ volatile (
 -        "movl %3, %%ecx\n"
 -        "pxor %%mm7, %%mm7\n"
 -        "pxor %%mm6, %%mm6\n"
 -
 -        "movq (%0), %%mm0\n"
 -        "movq %%mm0, %%mm1\n"
 -        "psllq $8, %%mm0\n"
 -        "psrlq $8, %%mm1\n"
 -        "psrlq $8, %%mm0\n"
 -        "movq %%mm0, %%mm2\n"
 -        "movq %%mm1, %%mm3\n"
 -        "punpcklbw %%mm7, %%mm0\n"
 -        "punpcklbw %%mm7, %%mm1\n"
 -        "punpckhbw %%mm7, %%mm2\n"
 -        "punpckhbw %%mm7, %%mm3\n"
 -        "psubw %%mm1, %%mm0\n"
 -        "psubw %%mm3, %%mm2\n"
 -
 -        "add %2, %0\n"
 -
 -        "movq (%0), %%mm4\n"
 -        "movq %%mm4, %%mm1\n"
 -        "psllq $8, %%mm4\n"
 -        "psrlq $8, %%mm1\n"
 -        "psrlq $8, %%mm4\n"
 -        "movq %%mm4, %%mm5\n"
 -        "movq %%mm1, %%mm3\n"
 -        "punpcklbw %%mm7, %%mm4\n"
 -        "punpcklbw %%mm7, %%mm1\n"
 -        "punpckhbw %%mm7, %%mm5\n"
 -        "punpckhbw %%mm7, %%mm3\n"
 -        "psubw %%mm1, %%mm4\n"
 -        "psubw %%mm3, %%mm5\n"
 -        "psubw %%mm4, %%mm0\n"
 -        "psubw %%mm5, %%mm2\n"
 -        "pxor %%mm3, %%mm3\n"
 -        "pxor %%mm1, %%mm1\n"
 -        "pcmpgtw %%mm0, %%mm3\n\t"
 -        "pcmpgtw %%mm2, %%mm1\n\t"
 -        "pxor %%mm3, %%mm0\n"
 -        "pxor %%mm1, %%mm2\n"
 -        "psubw %%mm3, %%mm0\n"
 -        "psubw %%mm1, %%mm2\n"
 -        "paddw %%mm0, %%mm2\n"
 -        "paddw %%mm2, %%mm6\n"
 -
 -        "add %2, %0\n"
 -        "1:\n"
 -
 -        "movq (%0), %%mm0\n"
 -        "movq %%mm0, %%mm1\n"
 -        "psllq $8, %%mm0\n"
 -        "psrlq $8, %%mm1\n"
 -        "psrlq $8, %%mm0\n"
 -        "movq %%mm0, %%mm2\n"
 -        "movq %%mm1, %%mm3\n"
 -        "punpcklbw %%mm7, %%mm0\n"
 -        "punpcklbw %%mm7, %%mm1\n"
 -        "punpckhbw %%mm7, %%mm2\n"
 -        "punpckhbw %%mm7, %%mm3\n"
 -        "psubw %%mm1, %%mm0\n"
 -        "psubw %%mm3, %%mm2\n"
 -        "psubw %%mm0, %%mm4\n"
 -        "psubw %%mm2, %%mm5\n"
 -        "pxor  %%mm3, %%mm3\n"
 -        "pxor  %%mm1, %%mm1\n"
 -        "pcmpgtw %%mm4, %%mm3\n\t"
 -        "pcmpgtw %%mm5, %%mm1\n\t"
 -        "pxor  %%mm3, %%mm4\n"
 -        "pxor  %%mm1, %%mm5\n"
 -        "psubw %%mm3, %%mm4\n"
 -        "psubw %%mm1, %%mm5\n"
 -        "paddw %%mm4, %%mm5\n"
 -        "paddw %%mm5, %%mm6\n"
 -
 -        "add %2, %0\n"
 -
 -        "movq (%0), %%mm4\n"
 -        "movq      %%mm4, %%mm1\n"
 -        "psllq $8, %%mm4\n"
 -        "psrlq $8, %%mm1\n"
 -        "psrlq $8, %%mm4\n"
 -        "movq      %%mm4, %%mm5\n"
 -        "movq      %%mm1, %%mm3\n"
 -        "punpcklbw %%mm7, %%mm4\n"
 -        "punpcklbw %%mm7, %%mm1\n"
 -        "punpckhbw %%mm7, %%mm5\n"
 -        "punpckhbw %%mm7, %%mm3\n"
 -        "psubw     %%mm1, %%mm4\n"
 -        "psubw     %%mm3, %%mm5\n"
 -        "psubw     %%mm4, %%mm0\n"
 -        "psubw     %%mm5, %%mm2\n"
 -        "pxor      %%mm3, %%mm3\n"
 -        "pxor      %%mm1, %%mm1\n"
 -        "pcmpgtw   %%mm0, %%mm3\n\t"
 -        "pcmpgtw   %%mm2, %%mm1\n\t"
 -        "pxor      %%mm3, %%mm0\n"
 -        "pxor      %%mm1, %%mm2\n"
 -        "psubw     %%mm3, %%mm0\n"
 -        "psubw     %%mm1, %%mm2\n"
 -        "paddw     %%mm0, %%mm2\n"
 -        "paddw     %%mm2, %%mm6\n"
 -
 -        "add  %2, %0\n"
 -        "subl $2, %%ecx\n"
 -        " jnz 1b\n"
 -
 -        "movq      %%mm6, %%mm0\n"
 -        "punpcklwd %%mm7, %%mm0\n"
 -        "punpckhwd %%mm7, %%mm6\n"
 -        "paddd     %%mm0, %%mm6\n"
 -
 -        "movq  %%mm6, %%mm0\n"
 -        "psrlq $32,   %%mm6\n"
 -        "paddd %%mm6, %%mm0\n"
 -        "movd  %%mm0, %1\n"
 -        : "+r" (pix1), "=r" (tmp)
 -        : "r" (stride), "g" (h - 2)
 -        : "%ecx");
 -
 -    return tmp;
 -}
 -
 -static int hf_noise16_mmx(uint8_t *pix1, ptrdiff_t stride, int h)
 -{
 -    int tmp;
 -    uint8_t *pix = pix1;
 -
 -    __asm__ volatile (
 -        "movl %3, %%ecx\n"
 -        "pxor %%mm7, %%mm7\n"
 -        "pxor %%mm6, %%mm6\n"
 -
 -        "movq (%0), %%mm0\n"
 -        "movq 1(%0), %%mm1\n"
 -        "movq %%mm0, %%mm2\n"
 -        "movq %%mm1, %%mm3\n"
 -        "punpcklbw %%mm7, %%mm0\n"
 -        "punpcklbw %%mm7, %%mm1\n"
 -        "punpckhbw %%mm7, %%mm2\n"
 -        "punpckhbw %%mm7, %%mm3\n"
 -        "psubw %%mm1, %%mm0\n"
 -        "psubw %%mm3, %%mm2\n"
 -
 -        "add %2, %0\n"
 -
 -        "movq (%0), %%mm4\n"
 -        "movq 1(%0), %%mm1\n"
 -        "movq %%mm4, %%mm5\n"
 -        "movq %%mm1, %%mm3\n"
 -        "punpcklbw %%mm7, %%mm4\n"
 -        "punpcklbw %%mm7, %%mm1\n"
 -        "punpckhbw %%mm7, %%mm5\n"
 -        "punpckhbw %%mm7, %%mm3\n"
 -        "psubw %%mm1, %%mm4\n"
 -        "psubw %%mm3, %%mm5\n"
 -        "psubw %%mm4, %%mm0\n"
 -        "psubw %%mm5, %%mm2\n"
 -        "pxor %%mm3, %%mm3\n"
 -        "pxor %%mm1, %%mm1\n"
 -        "pcmpgtw %%mm0, %%mm3\n\t"
 -        "pcmpgtw %%mm2, %%mm1\n\t"
 -        "pxor %%mm3, %%mm0\n"
 -        "pxor %%mm1, %%mm2\n"
 -        "psubw %%mm3, %%mm0\n"
 -        "psubw %%mm1, %%mm2\n"
 -        "paddw %%mm0, %%mm2\n"
 -        "paddw %%mm2, %%mm6\n"
 -
 -        "add %2, %0\n"
 -        "1:\n"
 -
 -        "movq (%0), %%mm0\n"
 -        "movq 1(%0), %%mm1\n"
 -        "movq %%mm0, %%mm2\n"
 -        "movq %%mm1, %%mm3\n"
 -        "punpcklbw %%mm7, %%mm0\n"
 -        "punpcklbw %%mm7, %%mm1\n"
 -        "punpckhbw %%mm7, %%mm2\n"
 -        "punpckhbw %%mm7, %%mm3\n"
 -        "psubw %%mm1, %%mm0\n"
 -        "psubw %%mm3, %%mm2\n"
 -        "psubw %%mm0, %%mm4\n"
 -        "psubw %%mm2, %%mm5\n"
 -        "pxor %%mm3, %%mm3\n"
 -        "pxor %%mm1, %%mm1\n"
 -        "pcmpgtw %%mm4, %%mm3\n\t"
 -        "pcmpgtw %%mm5, %%mm1\n\t"
 -        "pxor %%mm3, %%mm4\n"
 -        "pxor %%mm1, %%mm5\n"
 -        "psubw %%mm3, %%mm4\n"
 -        "psubw %%mm1, %%mm5\n"
 -        "paddw %%mm4, %%mm5\n"
 -        "paddw %%mm5, %%mm6\n"
 -
 -        "add %2, %0\n"
 -
 -        "movq (%0), %%mm4\n"
 -        "movq 1(%0), %%mm1\n"
 -        "movq %%mm4, %%mm5\n"
 -        "movq %%mm1, %%mm3\n"
 -        "punpcklbw %%mm7, %%mm4\n"
 -        "punpcklbw %%mm7, %%mm1\n"
 -        "punpckhbw %%mm7, %%mm5\n"
 -        "punpckhbw %%mm7, %%mm3\n"
 -        "psubw %%mm1, %%mm4\n"
 -        "psubw %%mm3, %%mm5\n"
 -        "psubw %%mm4, %%mm0\n"
 -        "psubw %%mm5, %%mm2\n"
 -        "pxor %%mm3, %%mm3\n"
 -        "pxor %%mm1, %%mm1\n"
 -        "pcmpgtw %%mm0, %%mm3\n\t"
 -        "pcmpgtw %%mm2, %%mm1\n\t"
 -        "pxor %%mm3, %%mm0\n"
 -        "pxor %%mm1, %%mm2\n"
 -        "psubw %%mm3, %%mm0\n"
 -        "psubw %%mm1, %%mm2\n"
 -        "paddw %%mm0, %%mm2\n"
 -        "paddw %%mm2, %%mm6\n"
 -
 -        "add %2, %0\n"
 -        "subl $2, %%ecx\n"
 -        " jnz 1b\n"
 -
 -        "movq %%mm6, %%mm0\n"
 -        "punpcklwd %%mm7, %%mm0\n"
 -        "punpckhwd %%mm7, %%mm6\n"
 -        "paddd %%mm0, %%mm6\n"
 +int ff_sum_abs_dctelem_mmx(int16_t *block);
 +int ff_sum_abs_dctelem_mmxext(int16_t *block);
 +int ff_sum_abs_dctelem_sse2(int16_t *block);
 +int ff_sum_abs_dctelem_ssse3(int16_t *block);
 +int ff_sse8_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                 int line_size, int h);
++                ptrdiff_t stride, int h);
 +int ff_sse16_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                  int line_size, int h);
++                 ptrdiff_t stride, int h);
 +int ff_sse16_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                   int line_size, int h);
- int ff_hf_noise8_mmx(uint8_t *pix1, int lsize, int h);
- int ff_hf_noise16_mmx(uint8_t *pix1, int lsize, int h);
++                  ptrdiff_t stride, int h);
++int ff_hf_noise8_mmx(uint8_t *pix1, ptrdiff_t stride, int h);
++int ff_hf_noise16_mmx(uint8_t *pix1, ptrdiff_t stride, int h);
 +int ff_sad8_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                    int stride, int h);
++                   ptrdiff_t stride, int h);
 +int ff_sad16_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                     int stride, int h);
++                    ptrdiff_t stride, int h);
 +int ff_sad16_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                   int stride, int h);
++                  ptrdiff_t stride, int h);
 +int ff_sad8_x2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                       int stride, int h);
++                      ptrdiff_t stride, int h);
 +int ff_sad16_x2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                        int stride, int h);
++                       ptrdiff_t stride, int h);
 +int ff_sad16_x2_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                      int stride, int h);
++                     ptrdiff_t stride, int h);
 +int ff_sad8_y2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                       int stride, int h);
++                      ptrdiff_t stride, int h);
 +int ff_sad16_y2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                        int stride, int h);
++                       ptrdiff_t stride, int h);
 +int ff_sad16_y2_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                      int stride, int h);
++                     ptrdiff_t stride, int h);
 +int ff_sad8_approx_xy2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                               int stride, int h);
++                              ptrdiff_t stride, int h);
 +int ff_sad16_approx_xy2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                                int stride, int h);
++                               ptrdiff_t stride, int h);
 +int ff_sad16_approx_xy2_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                              int stride, int h);
++                             ptrdiff_t stride, int h);
 +int ff_vsad_intra8_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                           int line_size, int h);
++                          ptrdiff_t stride, int h);
 +int ff_vsad_intra16_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                            int line_size, int h);
++                           ptrdiff_t stride, int h);
 +int ff_vsad_intra16_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                          int line_size, int h);
++                         ptrdiff_t stride, int h);
 +int ff_vsad8_approx_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                     int line_size, int h);
++                    ptrdiff_t stride, int h);
 +int ff_vsad16_approx_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                      int line_size, int h);
++                     ptrdiff_t stride, int h);
 +int ff_vsad16_approx_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                    int line_size, int h);
++                   ptrdiff_t stride, int h);
  
- #define hadamard_func(cpu)                                              \
-     int ff_hadamard8_diff_ ## cpu(MpegEncContext *s, uint8_t *src1,     \
-                                   uint8_t *src2, int stride, int h);    \
-     int ff_hadamard8_diff16_ ## cpu(MpegEncContext *s, uint8_t *src1,   \
-                                     uint8_t *src2, int stride, int h);
 -        "movq %%mm6, %%mm0\n"
 -        "psrlq $32, %%mm6\n"
 -        "paddd %%mm6, %%mm0\n"
 -        "movd %%mm0, %1\n"
 -        : "+r" (pix1), "=r" (tmp)
 -        : "r" (stride), "g" (h - 2)
 -        : "%ecx");
++#define hadamard_func(cpu)                                                    \
++    int ff_hadamard8_diff_ ## cpu(MpegEncContext *s, uint8_t *src1,           \
++                                  uint8_t *src2, ptrdiff_t stride, int h);    \
++    int ff_hadamard8_diff16_ ## cpu(MpegEncContext *s, uint8_t *src1,         \
++                                    uint8_t *src2, ptrdiff_t stride, int h);
  
 -    return tmp + hf_noise8_mmx(pix + 8, stride, h);
 -}
 +hadamard_func(mmx)
 +hadamard_func(mmxext)
 +hadamard_func(sse2)
 +hadamard_func(ssse3)
  
 +#if HAVE_YASM
  static int nsse16_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,
-                       int line_size, int h)
+                       ptrdiff_t stride, int h)
  {
      int score1, score2;
  
      if (c)
-         score1 = c->mecc.sse[0](c, pix1, pix2, line_size, h);
+         score1 = c->mecc.sse[0](c, pix1, pix2, stride, h);
      else
-         score1 = ff_sse16_mmx(c, pix1, pix2, line_size, h);
-     score2 = ff_hf_noise16_mmx(pix1, line_size, h) + ff_hf_noise8_mmx(pix1+8, line_size, h)
-            - ff_hf_noise16_mmx(pix2, line_size, h) - ff_hf_noise8_mmx(pix2+8, line_size, h);
 -        score1 = sse16_mmx(c, pix1, pix2, stride, h);
 -    score2 = hf_noise16_mmx(pix1, stride, h) -
 -             hf_noise16_mmx(pix2, stride, h);
++        score1 = ff_sse16_mmx(c, pix1, pix2, stride, h);
++    score2 = ff_hf_noise16_mmx(pix1, stride, h) + ff_hf_noise8_mmx(pix1+8, stride, h)
++           - ff_hf_noise16_mmx(pix2, stride, h) - ff_hf_noise8_mmx(pix2+8, stride, h);
  
      if (c)
          return score1 + FFABS(score2) * c->avctx->nsse_weight;
  }
  
  static int nsse8_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,
-                      int line_size, int h)
+                      ptrdiff_t stride, int h)
  {
-     int score1 = ff_sse8_mmx(c, pix1, pix2, line_size, h);
-     int score2 = ff_hf_noise8_mmx(pix1, line_size, h) -
-                  ff_hf_noise8_mmx(pix2, line_size, h);
 -    int score1 = sse8_mmx(c, pix1, pix2, stride, h);
 -    int score2 = hf_noise8_mmx(pix1, stride, h) -
 -                 hf_noise8_mmx(pix2, stride, h);
++    int score1 = ff_sse8_mmx(c, pix1, pix2, stride, h);
++    int score2 = ff_hf_noise8_mmx(pix1, stride, h) -
++                 ff_hf_noise8_mmx(pix2, stride, h);
  
      if (c)
          return score1 + FFABS(score2) * c->avctx->nsse_weight;
          return score1 + FFABS(score2) * 8;
  }
  
 +#endif /* HAVE_YASM */
 +
 +#if HAVE_INLINE_ASM
 +
  static int vsad_intra16_mmx(MpegEncContext *v, uint8_t *pix, uint8_t *dummy,
-                             int line_size, int h)
+                             ptrdiff_t stride, int h)
  {
      int tmp;
  
 -    assert((((int) pix) & 7) == 0);
 -    assert((stride & 7) == 0);
 +    av_assert2((((int) pix) & 7) == 0);
-     av_assert2((line_size & 7) == 0);
++    av_assert2((stride & 7) == 0);
  
  #define SUM(in0, in1, out0, out1)               \
      "movq (%0), %%mm2\n"                        \
  }
  #undef SUM
  
 -static int vsad_intra16_mmxext(MpegEncContext *v, uint8_t *pix, uint8_t *dummy,
 -                               ptrdiff_t stride, int h)
 -{
 -    int tmp;
 -
 -    assert((((int) pix) & 7) == 0);
 -    assert((stride & 7) == 0);
 -
 -#define SUM(in0, in1, out0, out1)               \
 -    "movq (%0), " #out0 "\n"                    \
 -    "movq 8(%0), " #out1 "\n"                   \
 -    "add %2, %0\n"                              \
 -    "psadbw " #out0 ", " #in0 "\n"              \
 -    "psadbw " #out1 ", " #in1 "\n"              \
 -    "paddw " #in1 ", " #in0 "\n"                \
 -    "paddw " #in0 ", %%mm6\n"
 -
 -    __asm__ volatile (
 -        "movl %3, %%ecx\n"
 -        "pxor %%mm6, %%mm6\n"
 -        "pxor %%mm7, %%mm7\n"
 -        "movq (%0), %%mm0\n"
 -        "movq 8(%0), %%mm1\n"
 -        "add %2, %0\n"
 -        "jmp 2f\n"
 -        "1:\n"
 -
 -        SUM(%%mm4, %%mm5, %%mm0, %%mm1)
 -        "2:\n"
 -        SUM(%%mm0, %%mm1, %%mm4, %%mm5)
 -
 -        "subl $2, %%ecx\n"
 -        "jnz 1b\n"
 -
 -        "movd %%mm6, %1\n"
 -        : "+r" (pix), "=r" (tmp)
 -        : "r" (stride), "m" (h)
 -        : "%ecx");
 -
 -    return tmp;
 -}
 -#undef SUM
 -
  static int vsad16_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
-                       int line_size, int h)
+                       ptrdiff_t stride, int h)
  {
      int tmp;
  
 -    assert((((int) pix1) & 7) == 0);
 -    assert((((int) pix2) & 7) == 0);
 -    assert((stride & 7) == 0);
 +    av_assert2((((int) pix1) & 7) == 0);
 +    av_assert2((((int) pix2) & 7) == 0);
-     av_assert2((line_size & 7) == 0);
++    av_assert2((stride & 7) == 0);
  
  #define SUM(in0, in1, out0, out1)       \
      "movq (%0), %%mm2\n"                \
@@@ -276,9 -803,12 +276,10 @@@ DECLARE_ASM_CONST(8, uint64_t, round_ta
      0x0002000200020002ULL,
  };
  
- static inline void sad8_1_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 -DECLARE_ASM_CONST(8, uint64_t, bone) = 0x0101010101010101LL;
 -
+ static inline void sad8_1_mmx(uint8_t *blk1, uint8_t *blk2,
+                               ptrdiff_t stride, int h)
  {
-     x86_reg len = -(x86_reg)stride * h;
 -    x86_reg len = -(stride * h);
++    x86_reg len = -stride * h;
      __asm__ volatile (
          ".p2align 4                     \n\t"
          "1:                             \n\t"
          "add %3, %%"REG_a"              \n\t"
          " js 1b                         \n\t"
          : "+a" (len)
-         : "r" (blk1 - len), "r" (blk2 - len), "r" ((x86_reg) stride));
+         : "r" (blk1 - len), "r" (blk2 - len), "r" (stride));
  }
  
 -static inline void sad8_1_mmxext(uint8_t *blk1, uint8_t *blk2,
 -                                 ptrdiff_t stride, int h)
 -{
 -    __asm__ volatile (
 -        ".p2align 4                     \n\t"
 -        "1:                             \n\t"
 -        "movq (%1), %%mm0               \n\t"
 -        "movq (%1, %3), %%mm1           \n\t"
 -        "psadbw (%2), %%mm0             \n\t"
 -        "psadbw (%2, %3), %%mm1         \n\t"
 -        "paddw %%mm0, %%mm6             \n\t"
 -        "paddw %%mm1, %%mm6             \n\t"
 -        "lea (%1,%3,2), %1              \n\t"
 -        "lea (%2,%3,2), %2              \n\t"
 -        "sub $2, %0                     \n\t"
 -        " jg 1b                         \n\t"
 -        : "+r" (h), "+r" (blk1), "+r" (blk2)
 -        : "r" (stride));
 -}
 -
 -static int sad16_sse2(MpegEncContext *v, uint8_t *blk2, uint8_t *blk1,
 -                      ptrdiff_t stride, int h)
 -{
 -    int ret;
 -    __asm__ volatile (
 -        "pxor %%xmm2, %%xmm2            \n\t"
 -        ".p2align 4                     \n\t"
 -        "1:                             \n\t"
 -        "movdqu (%1), %%xmm0            \n\t"
 -        "movdqu (%1, %4), %%xmm1        \n\t"
 -        "psadbw (%2), %%xmm0            \n\t"
 -        "psadbw (%2, %4), %%xmm1        \n\t"
 -        "paddw %%xmm0, %%xmm2           \n\t"
 -        "paddw %%xmm1, %%xmm2           \n\t"
 -        "lea (%1,%4,2), %1              \n\t"
 -        "lea (%2,%4,2), %2              \n\t"
 -        "sub $2, %0                     \n\t"
 -        " jg 1b                         \n\t"
 -        "movhlps %%xmm2, %%xmm0         \n\t"
 -        "paddw   %%xmm0, %%xmm2         \n\t"
 -        "movd    %%xmm2, %3             \n\t"
 -        : "+r" (h), "+r" (blk1), "+r" (blk2), "=r" (ret)
 -        : "r" (stride));
 -    return ret;
 -}
 -
 -static inline void sad8_x2a_mmxext(uint8_t *blk1, uint8_t *blk2,
 -                                   ptrdiff_t stride, int h)
 -{
 -    __asm__ volatile (
 -        ".p2align 4                     \n\t"
 -        "1:                             \n\t"
 -        "movq (%1), %%mm0               \n\t"
 -        "movq (%1, %3), %%mm1           \n\t"
 -        "pavgb 1(%1), %%mm0             \n\t"
 -        "pavgb 1(%1, %3), %%mm1         \n\t"
 -        "psadbw (%2), %%mm0             \n\t"
 -        "psadbw (%2, %3), %%mm1         \n\t"
 -        "paddw %%mm0, %%mm6             \n\t"
 -        "paddw %%mm1, %%mm6             \n\t"
 -        "lea (%1,%3,2), %1              \n\t"
 -        "lea (%2,%3,2), %2              \n\t"
 -        "sub $2, %0                     \n\t"
 -        " jg 1b                         \n\t"
 -        : "+r" (h), "+r" (blk1), "+r" (blk2)
 -        : "r" (stride));
 -}
 -
 -static inline void sad8_y2a_mmxext(uint8_t *blk1, uint8_t *blk2,
 -                                   ptrdiff_t stride, int h)
 -{
 -    __asm__ volatile (
 -        "movq (%1), %%mm0               \n\t"
 -        "add %3, %1                     \n\t"
 -        ".p2align 4                     \n\t"
 -        "1:                             \n\t"
 -        "movq (%1), %%mm1               \n\t"
 -        "movq (%1, %3), %%mm2           \n\t"
 -        "pavgb %%mm1, %%mm0             \n\t"
 -        "pavgb %%mm2, %%mm1             \n\t"
 -        "psadbw (%2), %%mm0             \n\t"
 -        "psadbw (%2, %3), %%mm1         \n\t"
 -        "paddw %%mm0, %%mm6             \n\t"
 -        "paddw %%mm1, %%mm6             \n\t"
 -        "movq %%mm2, %%mm0              \n\t"
 -        "lea (%1,%3,2), %1              \n\t"
 -        "lea (%2,%3,2), %2              \n\t"
 -        "sub $2, %0                     \n\t"
 -        " jg 1b                         \n\t"
 -        : "+r" (h), "+r" (blk1), "+r" (blk2)
 -        : "r" (stride));
 -}
 -
 -static inline void sad8_4_mmxext(uint8_t *blk1, uint8_t *blk2,
 -                                 ptrdiff_t stride, int h)
 -{
 -    __asm__ volatile (
 -        "movq "MANGLE(bone)", %%mm5     \n\t"
 -        "movq (%1), %%mm0               \n\t"
 -        "pavgb 1(%1), %%mm0             \n\t"
 -        "add %3, %1                     \n\t"
 -        ".p2align 4                     \n\t"
 -        "1:                             \n\t"
 -        "movq (%1), %%mm1               \n\t"
 -        "movq (%1,%3), %%mm2            \n\t"
 -        "pavgb 1(%1), %%mm1             \n\t"
 -        "pavgb 1(%1,%3), %%mm2          \n\t"
 -        "psubusb %%mm5, %%mm1           \n\t"
 -        "pavgb %%mm1, %%mm0             \n\t"
 -        "pavgb %%mm2, %%mm1             \n\t"
 -        "psadbw (%2), %%mm0             \n\t"
 -        "psadbw (%2,%3), %%mm1          \n\t"
 -        "paddw %%mm0, %%mm6             \n\t"
 -        "paddw %%mm1, %%mm6             \n\t"
 -        "movq %%mm2, %%mm0              \n\t"
 -        "lea (%1,%3,2), %1              \n\t"
 -        "lea (%2,%3,2), %2              \n\t"
 -        "sub $2, %0                     \n\t"
 -        " jg 1b                         \n\t"
 -        : "+r" (h), "+r" (blk1), "+r" (blk2)
 -        : "r" (stride));
 -}
 -
  static inline void sad8_2_mmx(uint8_t *blk1a, uint8_t *blk1b, uint8_t *blk2,
-                               int stride, int h)
+                               ptrdiff_t stride, int h)
  {
-     x86_reg len = -(x86_reg)stride * h;
 -    x86_reg len = -(stride * h);
++    x86_reg len = -stride * h;
      __asm__ volatile (
          ".p2align 4                     \n\t"
          "1:                             \n\t"
          " js 1b                         \n\t"
          : "+a" (len)
          : "r" (blk1a - len), "r" (blk1b - len), "r" (blk2 - len),
-           "r" ((x86_reg) stride));
+           "r" (stride));
  }
  
- static inline void sad8_4_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
+ static inline void sad8_4_mmx(uint8_t *blk1, uint8_t *blk2,
+                               ptrdiff_t stride, int h)
  {
-     x86_reg len = -(x86_reg)stride * h;
 -    x86_reg len = -(stride * h);
++    x86_reg len = -stride * h;
      __asm__ volatile (
          "movq  (%1, %%"REG_a"), %%mm0   \n\t"
          "movq 1(%1, %%"REG_a"), %%mm2   \n\t"
          " js 1b                         \n\t"
          : "+a" (len)
          : "r" (blk1 - len), "r" (blk1 - len + stride), "r" (blk2 - len),
-           "r" ((x86_reg) stride), "m" (round_tab[2]));
 -          "r" (stride));
++          "r" (stride), "m" (round_tab[2]));
  }
  
  static inline int sum_mmx(void)
      return ret & 0xFFFF;
  }
  
- static inline void sad8_x2a_mmx(uint8_t *blk1, uint8_t *blk2, int stride, int h)
 -static inline int sum_mmxext(void)
 -{
 -    int ret;
 -    __asm__ volatile (
 -        "movd %%mm6, %0                 \n\t"
 -        : "=r" (ret));
 -    return ret;
 -}
 -
+ static inline void sad8_x2a_mmx(uint8_t *blk1, uint8_t *blk2,
+                                 ptrdiff_t stride, int h)
  {
      sad8_2_mmx(blk1, blk1 + 1, blk2, stride, h);
  }
@@@ -430,9 -1095,9 +434,9 @@@ static inline void sad8_y2a_mmx(uint8_
  
  #define PIX_SAD(suf)                                                    \
  static int sad8_ ## suf(MpegEncContext *v, uint8_t *blk2,               \
-                         uint8_t *blk1, int stride, int h)               \
+                         uint8_t *blk1, ptrdiff_t stride, int h)         \
  {                                                                       \
 -    assert(h == 8);                                                     \
 +    av_assert2(h == 8);                                                     \
      __asm__ volatile (                                                  \
          "pxor %%mm7, %%mm7     \n\t"                                    \
          "pxor %%mm6, %%mm6     \n\t"                                    \
  }                                                                       \
                                                                          \
  static int sad8_x2_ ## suf(MpegEncContext *v, uint8_t *blk2,            \
-                            uint8_t *blk1, int stride, int h)            \
+                            uint8_t *blk1, ptrdiff_t stride, int h)      \
  {                                                                       \
 -    assert(h == 8);                                                     \
 +    av_assert2(h == 8);                                                     \
      __asm__ volatile (                                                  \
          "pxor %%mm7, %%mm7     \n\t"                                    \
          "pxor %%mm6, %%mm6     \n\t"                                    \
  }                                                                       \
                                                                          \
  static int sad8_y2_ ## suf(MpegEncContext *v, uint8_t *blk2,            \
-                            uint8_t *blk1, int stride, int h)            \
+                            uint8_t *blk1, ptrdiff_t stride, int h)      \
  {                                                                       \
 -    assert(h == 8);                                                     \
 +    av_assert2(h == 8);                                                     \
      __asm__ volatile (                                                  \
          "pxor %%mm7, %%mm7     \n\t"                                    \
          "pxor %%mm6, %%mm6     \n\t"                                    \
  }                                                                       \
                                                                          \
  static int sad8_xy2_ ## suf(MpegEncContext *v, uint8_t *blk2,           \
-                             uint8_t *blk1, int stride, int h)           \
+                             uint8_t *blk1, ptrdiff_t stride, int h)     \
  {                                                                       \
 -    assert(h == 8);                                                     \
 +    av_assert2(h == 8);                                                     \
      __asm__ volatile (                                                  \
          "pxor %%mm7, %%mm7     \n\t"                                    \
          "pxor %%mm6, %%mm6     \n\t"                                    \