@@ -405,7 +405,8 @@ static inline void mc_dir_part(AVSContext *h, AVFrame *pic,

           || full_my < 0-extra_height

           || full_mx + 16/*FIXME*/ > pic_width + extra_width

           || full_my + 16/*FIXME*/ > pic_height + extra_height){

-        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_y - 2 - 2*h->l_stride, h->l_stride,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->l_stride,

+                            src_y - 2 - 2*h->l_stride, h->l_stride,

                             16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);

         src_y= h->edge_emu_buffer + 2 + 2*h->l_stride;

         emu=1;

@@ -414,14 +415,14 @@ static inline void mc_dir_part(AVSContext *h, AVFrame *pic,

     qpix_op[luma_xy](dest_y, src_y, h->l_stride); //FIXME try variable height perhaps?

     if(emu){

-        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cb, h->c_stride,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->c_stride, src_cb, h->c_stride,

                             9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);

         src_cb= h->edge_emu_buffer;

     }

     chroma_op(dest_cb, src_cb, h->c_stride, chroma_height, mx&7, my&7);

     if(emu){

-        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cr, h->c_stride,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->c_stride, src_cr, h->c_stride,

                             9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);

         src_cr= h->edge_emu_buffer;

     }

@@ -1414,7 +1414,8 @@ static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5],

         y + p->yblen > p->height+EDGE_WIDTH/2 ||

         x < 0 || y < 0) {

         for (i = 0; i < nplanes; i++) {

-            ff_emulated_edge_mc(s->edge_emu_buffer[i], src[i], p->stride,

+            ff_emulated_edge_mc(s->edge_emu_buffer[i], p->stride,

+                                src[i], p->stride,

                                 p->xblen, p->yblen, x, y,

                                 p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);

             src[i] = s->edge_emu_buffer[i];

@@ -932,7 +932,7 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

         full_my                <          0 - extra_height ||

         full_mx + 16 /*FIXME*/ > pic_width  + extra_width  ||

         full_my + 16 /*FIXME*/ > pic_height + extra_height) {

-        h->vdsp.emulated_edge_mc(h->edge_emu_buffer,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->mb_linesize,

                                  src_y - (2 << pixel_shift) - 2 * h->mb_linesize,

                                  h->mb_linesize,

                                  16 + 5, 16 + 5 /*FIXME*/, full_mx - 2,

@@ -951,7 +951,7 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

     if (chroma_idc == 3 /* yuv444 */) {

         src_cb = pic->f.data[1] + offset;

         if (emu) {

-            h->vdsp.emulated_edge_mc(h->edge_emu_buffer,

+            h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->mb_linesize,

                                      src_cb - (2 << pixel_shift) - 2 * h->mb_linesize,

                                      h->mb_linesize,

                                      16 + 5, 16 + 5 /*FIXME*/,

@@ -965,7 +965,7 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

         src_cr = pic->f.data[2] + offset;

         if (emu) {

-            h->vdsp.emulated_edge_mc(h->edge_emu_buffer,

+            h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->mb_linesize,

                                      src_cr - (2 << pixel_shift) - 2 * h->mb_linesize,

                                      h->mb_linesize,

                                      16 + 5, 16 + 5 /*FIXME*/,

@@ -992,7 +992,7 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

              (my >> ysh) * h->mb_uvlinesize;

     if (emu) {

-        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cb, h->mb_uvlinesize,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->mb_uvlinesize, src_cb, h->mb_uvlinesize,

                                  9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh),

                                  pic_width >> 1, pic_height >> (chroma_idc == 1 /* yuv420 */));

         src_cb = h->edge_emu_buffer;

@@ -1002,7 +1002,7 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

               mx & 7, (my << (chroma_idc == 2 /* yuv422 */)) & 7);

     if (emu) {

-        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cr, h->mb_uvlinesize,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->mb_uvlinesize, src_cr, h->mb_uvlinesize,

                                  9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh),

                                  pic_width >> 1, pic_height >> (chroma_idc == 1 /* yuv420 */));

         src_cr = h->edge_emu_buffer;

@@ -2204,7 +2204,8 @@ static inline int hpel_motion_lowres(MpegEncContext *s,

     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||

         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,

+                                src, s->linesize, w + 1,

                                 (h + 1) << field_based, src_x,

                                 src_y   << field_based,

                                 h_edge_pos,

@@ -2306,18 +2307,20 @@ static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,

     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) || uvsrc_y<0 ||

         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, linesize >> field_based, ptr_y,

                                 linesize >> field_based, 17, 17 + field_based,

                                 src_x, src_y << field_based, h_edge_pos,

                                 v_edge_pos);

         ptr_y = s->edge_emu_buffer;

         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {

             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;

-            s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,

+            s->vdsp.emulated_edge_mc(uvbuf, uvlinesize >> field_based,

+                                    ptr_cb, uvlinesize >> field_based, 9,

                                     9 + field_based,

                                     uvsrc_x, uvsrc_y << field_based,

                                     h_edge_pos >> 1, v_edge_pos >> 1);

-            s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,

+            s->vdsp.emulated_edge_mc(uvbuf + 16, uvlinesize >> field_based,

+                                    ptr_cr, uvlinesize >> field_based, 9,

                                     9 + field_based,

                                     uvsrc_x, uvsrc_y << field_based,

                                     h_edge_pos >> 1, v_edge_pos >> 1);

@@ -2390,7 +2393,7 @@ static inline void chroma_4mv_motion_lowres(MpegEncContext *s,

     ptr = ref_picture[1] + offset;

     if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||

         (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize, ptr, s->uvlinesize,

                                 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);

         ptr = s->edge_emu_buffer;

         emu = 1;

@@ -2401,7 +2404,8 @@ static inline void chroma_4mv_motion_lowres(MpegEncContext *s,

     ptr = ref_picture[2] + offset;

     if (emu) {

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize,

+                                ptr, s->uvlinesize, 9, 9,

                                 src_x, src_y, h_edge_pos, v_edge_pos);

         ptr = s->edge_emu_buffer;

     }

@@ -1819,14 +1819,14 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s,

         uint8_t *ebuf = s->edge_emu_buffer + 32;

         int cw = (s->width  + s->chroma_x_shift) >> s->chroma_x_shift;

         int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;

-        s->vdsp.emulated_edge_mc(ebuf, ptr_y, wrap_y, 16, 16, mb_x * 16,

+        s->vdsp.emulated_edge_mc(ebuf, wrap_y, ptr_y, wrap_y, 16, 16, mb_x * 16,

                                  mb_y * 16, s->width, s->height);

         ptr_y = ebuf;

-        s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb, wrap_c, mb_block_width,

+        s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, wrap_c, ptr_cb, wrap_c, mb_block_width,

                                  mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,

                                  cw, ch);

         ptr_cb = ebuf + 18 * wrap_y;

-        s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, ptr_cr, wrap_c, mb_block_width,

+        s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 16, wrap_c, ptr_cr, wrap_c, mb_block_width,

                                  mb_block_height, mb_x * mb_block_width, mb_y * mb_block_height,

                                  cw, ch);

         ptr_cr = ebuf + 18 * wrap_y + 16;

@@ -63,7 +63,9 @@ static void gmc1_motion(MpegEncContext *s,

         if(   (unsigned)src_x >= FFMAX(s->h_edge_pos - 17, 0)

            || (unsigned)src_y >= FFMAX(s->v_edge_pos - 17, 0)){

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);

+            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, linesize,

+                                     ptr, linesize, 17, 17, src_x, src_y,

+                                     s->h_edge_pos, s->v_edge_pos);

             ptr= s->edge_emu_buffer;

         }

@@ -100,7 +102,9 @@ static void gmc1_motion(MpegEncContext *s,

     ptr = ref_picture[1] + offset;

         if(   (unsigned)src_x >= FFMAX((s->h_edge_pos>>1) - 9, 0)

            || (unsigned)src_y >= FFMAX((s->v_edge_pos>>1) - 9, 0)){

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);

+            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, uvlinesize,

+                                     ptr, uvlinesize, 9, 9, src_x, src_y,

+                                     s->h_edge_pos>>1, s->v_edge_pos>>1);

             ptr= s->edge_emu_buffer;

             emu=1;

         }

@@ -108,7 +112,9 @@ static void gmc1_motion(MpegEncContext *s,

     ptr = ref_picture[2] + offset;

     if(emu){

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, uvlinesize,

+                                 ptr, uvlinesize, 9, 9, src_x, src_y,

+                                 s->h_edge_pos>>1, s->v_edge_pos>>1);

         ptr= s->edge_emu_buffer;

     }

     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);

@@ -196,8 +202,9 @@ static inline int hpel_motion(MpegEncContext *s,

     if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){

         if(   (unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x&1) - 8, 0)

            || (unsigned)src_y > FFMAX(s->v_edge_pos - (motion_y&1) - 8, 0)){

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, 9, 9,

-                             src_x, src_y, s->h_edge_pos, s->v_edge_pos);

+            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,

+                                     src, s->linesize, 9, 9,

+                                     src_x, src_y, s->h_edge_pos, s->v_edge_pos);

             src= s->edge_emu_buffer;

             emu=1;

         }

@@ -287,19 +294,19 @@ if(s->quarter_sample)

                         "MPEG motion vector out of boundary (%d %d)\n", src_x, src_y);

                 return;

             }

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize,

-                                17, 17+field_based,

-                                src_x, src_y<<field_based,

-                                s->h_edge_pos, s->v_edge_pos);

+            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,

+                                     ptr_y, s->linesize, 17, 17+field_based,

+                                     src_x, src_y<<field_based,

+                                     s->h_edge_pos, s->v_edge_pos);

             ptr_y = s->edge_emu_buffer;

             if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;

-                s->vdsp.emulated_edge_mc(uvbuf ,

+                s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize,

                                     ptr_cb, s->uvlinesize,

                                     9, 9+field_based,

                                     uvsrc_x, uvsrc_y<<field_based,

                                     s->h_edge_pos>>1, s->v_edge_pos>>1);

-                s->vdsp.emulated_edge_mc(uvbuf+16,

+                s->vdsp.emulated_edge_mc(uvbuf+16, s->uvlinesize,

                                     ptr_cr, s->uvlinesize,

                                     9, 9+field_based,

                                     uvsrc_x, uvsrc_y<<field_based,

@@ -501,20 +508,23 @@ static inline void qpel_motion(MpegEncContext *s,

     if(   (unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x&3) - 16, 0)

        || (unsigned)src_y > FFMAX(   v_edge_pos - (motion_y&3) - h , 0)){

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize,

-                            17, 17+field_based, src_x, src_y<<field_based,

-                            s->h_edge_pos, s->v_edge_pos);

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,

+                                 ptr_y, s->linesize,

+                                 17, 17+field_based, src_x, src_y<<field_based,

+                                 s->h_edge_pos, s->v_edge_pos);

         ptr_y= s->edge_emu_buffer;

         if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

             uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;

-            s->vdsp.emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize,

-                                9, 9 + field_based,

-                                uvsrc_x, uvsrc_y<<field_based,

-                                s->h_edge_pos>>1, s->v_edge_pos>>1);

-            s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize,

-                                9, 9 + field_based,

-                                uvsrc_x, uvsrc_y<<field_based,

-                                s->h_edge_pos>>1, s->v_edge_pos>>1);

+            s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize,

+                                     ptr_cb, s->uvlinesize,

+                                     9, 9 + field_based,

+                                     uvsrc_x, uvsrc_y<<field_based,

+                                     s->h_edge_pos>>1, s->v_edge_pos>>1);

+            s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize,

+                                     ptr_cr, s->uvlinesize,

+                                     9, 9 + field_based,

+                                     uvsrc_x, uvsrc_y<<field_based,

+                                     s->h_edge_pos>>1, s->v_edge_pos>>1);

             ptr_cb= uvbuf;

             ptr_cr= uvbuf + 16;

         }

@@ -581,9 +591,9 @@ static void chroma_4mv_motion(MpegEncContext *s,

     if(s->flags&CODEC_FLAG_EMU_EDGE){

         if(   (unsigned)src_x > FFMAX((s->h_edge_pos>>1) - (dxy &1) - 8, 0)

            || (unsigned)src_y > FFMAX((s->v_edge_pos>>1) - (dxy>>1) - 8, 0)){

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,

-                                9, 9, src_x, src_y,

-                                s->h_edge_pos>>1, s->v_edge_pos>>1);

+            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize,

+                                     ptr, s->uvlinesize, 9, 9, src_x, src_y,

+                                     s->h_edge_pos>>1, s->v_edge_pos>>1);

             ptr= s->edge_emu_buffer;

             emu=1;

         }

@@ -592,9 +602,9 @@ static void chroma_4mv_motion(MpegEncContext *s,

     ptr = ref_picture[2] + offset;

     if(emu){

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,

-                            9, 9, src_x, src_y,

-                            s->h_edge_pos>>1, s->v_edge_pos>>1);

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize,

+                                 ptr, s->uvlinesize, 9, 9, src_x, src_y,

+                                 s->h_edge_pos>>1, s->v_edge_pos>>1);

         ptr= s->edge_emu_buffer;

     }

     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);

@@ -761,10 +771,10 @@ static av_always_inline void MPV_motion_internal(MpegEncContext *s,

                 if(s->flags&CODEC_FLAG_EMU_EDGE){

                     if(   (unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x&3) - 8, 0)

                        || (unsigned)src_y > FFMAX(s->v_edge_pos - (motion_y&3) - 8, 0)){

-                        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,

-                                            s->linesize, 9, 9,

-                                            src_x, src_y,

-                                            s->h_edge_pos, s->v_edge_pos);

+                        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,

+                                                 ptr, s->linesize, 9, 9,

+                                                 src_x, src_y,

+                                                 s->h_edge_pos, s->v_edge_pos);

                         ptr= s->edge_emu_buffer;

                     }

                 }

@@ -724,13 +724,16 @@ static inline void rv34_mc(RV34DecContext *r, const int block_type,

         uint8_t *uvbuf = s->edge_emu_buffer + 22 * s->linesize;

         srcY -= 2 + 2*s->linesize;

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, (width<<3)+6, (height<<3)+6,

-                            src_x - 2, src_y - 2, s->h_edge_pos, s->v_edge_pos);

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize, srcY, s->linesize,

+                                 (width<<3)+6, (height<<3)+6, src_x - 2, src_y - 2,

+                                 s->h_edge_pos, s->v_edge_pos);

         srcY = s->edge_emu_buffer + 2 + 2*s->linesize;

-        s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, (width<<2)+1, (height<<2)+1,

-                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);

-        s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, (width<<2)+1, (height<<2)+1,

-                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);

+        s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize, srcU, s->uvlinesize,

+                                 (width<<2)+1, (height<<2)+1, uvsrc_x, uvsrc_y,

+                                 s->h_edge_pos >> 1, s->v_edge_pos >> 1);

+        s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize, srcV, s->uvlinesize,

+                                 (width<<2)+1, (height<<2)+1, uvsrc_x, uvsrc_y,

+                                 s->h_edge_pos >> 1, s->v_edge_pos >> 1);

         srcU = uvbuf;

         srcV = uvbuf + 16;

     }

@@ -349,7 +349,9 @@ void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t st

         src += sx + sy*stride;

         if(   (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)

            || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){

-            s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);

+            s->vdsp.emulated_edge_mc(tmp + MB_SIZE, stride, src, stride,

+                                     b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,

+                                     sx, sy, w, h);

             src= tmp + MB_SIZE;

         }

@@ -317,7 +317,8 @@ static inline void svq3_mc_dir_part(SVQ3Context *s,

     src  = pic->f.data[0] + mx + my * h->linesize;

     if (emu) {

-        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src, h->linesize,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->linesize,

+                                 src, h->linesize,

                                  width + 1, height + 1,

                                  mx, my, s->h_edge_pos, s->v_edge_pos);

         src = h->edge_emu_buffer;

@@ -343,7 +344,8 @@ static inline void svq3_mc_dir_part(SVQ3Context *s,

             src  = pic->f.data[i] + mx + my * h->uvlinesize;

             if (emu) {

-                h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src, h->uvlinesize,

+                h->vdsp.emulated_edge_mc(h->edge_emu_buffer, h->uvlinesize,

+                                         src, h->uvlinesize,

                                          width + 1, height + 1,

                                          mx, my, (s->h_edge_pos >> 1),

                                          s->v_edge_pos >> 1);

@@ -454,15 +454,18 @@ static void vc1_mc_1mv(VC1Context *v, int dir)

         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;

         srcY -= s->mspel * (1 + s->linesize);

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,

+                                 srcY, s->linesize,

                                  17 + s->mspel * 2, 17 + s->mspel * 2,

                                  src_x - s->mspel, src_y - s->mspel,

                                  s->h_edge_pos, v_edge_pos);

         srcY = s->edge_emu_buffer;

-        s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,

-                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);

-        s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,

-                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);

+        s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize, srcU, s->uvlinesize,

+                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,

+                                 s->h_edge_pos >> 1, v_edge_pos >> 1);

+        s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize, srcV, s->uvlinesize,

+                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,

+                                 s->h_edge_pos >> 1, v_edge_pos >> 1);

         srcU = uvbuf;

         srcV = uvbuf + 16;

         /* if we deal with range reduction we need to scale source blocks */

@@ -697,7 +700,7 @@ static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)

         || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {

         srcY -= s->mspel * (1 + (s->linesize << fieldmv));

         /* check emulate edge stride and offset */

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize, srcY, s->linesize,

                                  9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,

                                  src_x - s->mspel, src_y - (s->mspel << fieldmv),

                                  s->h_edge_pos, v_edge_pos);

@@ -912,11 +915,11 @@ static void vc1_mc_4mv_chroma(VC1Context *v, int dir)

         || s->h_edge_pos < 18 || v_edge_pos < 18

         || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9

         || (unsigned)uvsrc_y > (v_edge_pos    >> 1) - 9) {

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize,

-                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize, srcU,

+                                 s->uvlinesize, 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,

                                  s->h_edge_pos >> 1, v_edge_pos >> 1);

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,

-                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, s->uvlinesize, srcV,

+                                 s->uvlinesize, 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,

                                  s->h_edge_pos >> 1, v_edge_pos >> 1);

         srcU = s->edge_emu_buffer;

         srcV = s->edge_emu_buffer + 16;

@@ -1033,12 +1036,12 @@ static void vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)

             || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)

             || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5

             || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,

-                                     5, (5 << fieldmv), uvsrc_x, uvsrc_y,

-                                     s->h_edge_pos >> 1, v_edge_pos);

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,

-                                     5, (5 << fieldmv), uvsrc_x, uvsrc_y,

-                                     s->h_edge_pos >> 1, v_edge_pos);

+            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize, srcU,

+                                     s->uvlinesize, 5, (5 << fieldmv), uvsrc_x,

+                                     uvsrc_y, s->h_edge_pos >> 1, v_edge_pos);

+            s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, s->uvlinesize, srcV,

+                                     s->uvlinesize, 5, (5 << fieldmv), uvsrc_x,

+                                     uvsrc_y, s->h_edge_pos >> 1, v_edge_pos);

             srcU = s->edge_emu_buffer;

             srcV = s->edge_emu_buffer + 16;

@@ -1966,15 +1969,17 @@ static void vc1_interp_mc(VC1Context *v)

         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;

         srcY -= s->mspel * (1 + s->linesize);

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize, srcY, s->linesize,

                                  17 + s->mspel * 2, 17 + s->mspel * 2,

                                  src_x - s->mspel, src_y - s->mspel,

                                  s->h_edge_pos, v_edge_pos);

         srcY = s->edge_emu_buffer;

-        s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,

-                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);

-        s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,

-                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);

+        s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize, srcU, s->uvlinesize,

+                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,

+                                 s->h_edge_pos >> 1, v_edge_pos >> 1);

+        s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize, srcV, s->uvlinesize,

+                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,

+                                 s->h_edge_pos >> 1, v_edge_pos >> 1);

         srcU = uvbuf;

         srcV = uvbuf + 16;

         /* if we deal with range reduction we need to scale source blocks */

@@ -30,9 +30,10 @@

 #include <stdint.h>

 #define EMULATED_EDGE(depth) \

-void ff_emulated_edge_mc_ ## depth (uint8_t *buf, const uint8_t *src, ptrdiff_t linesize,\

-                         int block_w, int block_h,\

-                         int src_x, int src_y, int w, int h);

+void ff_emulated_edge_mc_ ## depth(uint8_t *dst, ptrdiff_t dst_stride, \

+                                   const uint8_t *src, ptrdiff_t src_stride, \

+                                   int block_w, int block_h,\

+                                   int src_x, int src_y, int w, int h);

 EMULATED_EDGE(8)

 EMULATED_EDGE(16)

@@ -42,10 +43,12 @@ typedef struct VideoDSPContext {

      * Copy a rectangular area of samples to a temporary buffer and replicate

      * the border samples.

      *

-     * @param buf destination buffer

+     * @param dst destination buffer

+     * @param dst_stride number of bytes between 2 vertically adjacent samples

+     *                   in destination buffer

      * @param src source buffer

-     * @param linesize number of bytes between 2 vertically adjacent samples

-     *                 in both the source and destination buffers

+     * @param src_stride number of bytes between 2 vertically adjacent samples

+     *                   in source buffer

      * @param block_w width of block

      * @param block_h height of block

      * @param src_x x coordinate of the top left sample of the block in the

@@ -55,8 +58,9 @@ typedef struct VideoDSPContext {

      * @param w width of the source buffer

      * @param h height of the source buffer

      */

-    void (*emulated_edge_mc)(uint8_t *buf, const uint8_t *src,

-                             ptrdiff_t linesize, int block_w, int block_h,

+    void (*emulated_edge_mc)(uint8_t *dst, ptrdiff_t dst_stride,

+                             const uint8_t *src, ptrdiff_t src_stride,

+                             int block_w, int block_h,

                              int src_x, int src_y, int w, int h);

     /**

@@ -20,10 +20,10 @@

  */

 #include "bit_depth_template.c"

-void FUNC(ff_emulated_edge_mc)(uint8_t *buf, const uint8_t *src,

-                                      ptrdiff_t linesize,

-                                      int block_w, int block_h,

-                                      int src_x, int src_y, int w, int h)

+void FUNC(ff_emulated_edge_mc)(uint8_t *buf, ptrdiff_t buf_stride,

+                               const uint8_t *src, ptrdiff_t src_stride,

+                               int block_w, int block_h,

+                               int src_x, int src_y, int w, int h)

 {

     int x, y;

     int start_y, start_x, end_y, end_x;

@@ -32,12 +32,12 @@ void FUNC(ff_emulated_edge_mc)(uint8_t *buf, const uint8_t *src,

         return;

     if (src_y >= h) {

-        src -= src_y * linesize;

-        src += (h - 1) * linesize;

+        src -= src_y * src_stride;

+        src += (h - 1) * src_stride;

         src_y = h - 1;

     } else if (src_y <= -block_h) {

-        src -= src_y * linesize;

-        src += (1 - block_h) * linesize;

+        src -= src_y * src_stride;

+        src += (1 - block_h) * src_stride;

         src_y = 1 - block_h;

     }

     if (src_x >= w) {

@@ -56,30 +56,30 @@ void FUNC(ff_emulated_edge_mc)(uint8_t *buf, const uint8_t *src,

     av_assert2(start_x < end_x && block_w);

     w    = end_x - start_x;

-    src += start_y * linesize + start_x * sizeof(pixel);

+    src += start_y * src_stride + start_x * sizeof(pixel);

     buf += start_x * sizeof(pixel);

     // top

     for (y = 0; y < start_y; y++) {

         memcpy(buf, src, w * sizeof(pixel));

-        buf += linesize;

+        buf += buf_stride;

     }

     // copy existing part

     for (; y < end_y; y++) {

         memcpy(buf, src, w * sizeof(pixel));

-        src += linesize;

-        buf += linesize;

+        src += src_stride;

+        buf += buf_stride;

     }

     // bottom

-    src -= linesize;

+    src -= src_stride;

     for (; y < block_h; y++) {

         memcpy(buf, src, w * sizeof(pixel));

-        buf += linesize;

+        buf += buf_stride;

     }

-    buf -= block_h * linesize + start_x * sizeof(pixel);

+    buf -= block_h * buf_stride + start_x * sizeof(pixel);

     while (block_h--) {

         pixel *bufp = (pixel *) buf;

@@ -92,6 +92,6 @@ void FUNC(ff_emulated_edge_mc)(uint8_t *buf, const uint8_t *src,

         for (x = end_x; x < block_w; x++) {

             bufp[x] = bufp[end_x - 1];

         }

-        buf += linesize;

+        buf += buf_stride;

     }

 }

@@ -1549,7 +1549,10 @@ static void render_slice(Vp3DecodeContext *s, int slice)

                             uint8_t *temp= s->edge_emu_buffer;

                             if(stride<0) temp -= 8*stride;

-                            s->vdsp.emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);

+                            s->vdsp.emulated_edge_mc(temp, stride,

+                                                     motion_source, stride,

+                                                     9, 9, src_x, src_y,

+                                                     plane_width, plane_height);

                             motion_source= temp;

                         }

                     }

@@ -339,7 +339,7 @@ static void vp56_mc(VP56Context *s, int b, int plane, uint8_t *src,

     if (x<0 || x+12>=s->plane_width[plane] ||

         y<0 || y+12>=s->plane_height[plane]) {

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, stride,

                             src + s->block_offset[b] + (dy-2)*stride + (dx-2),

                             stride, 12, 12, x, y,

                             s->plane_width[plane],

@@ -45,7 +45,6 @@ static void free_buffers(VP8Context *s)

             pthread_mutex_destroy(&s->thread_data[i].lock);

 #endif

             av_freep(&s->thread_data[i].filter_strength);

-            av_freep(&s->thread_data[i].edge_emu_buffer);

         }

     av_freep(&s->thread_data);

     av_freep(&s->macroblocks_base);

@@ -1186,7 +1185,7 @@ void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst,

     uint8_t *src = ref->f->data[0];

     if (AV_RN32A(mv)) {

-

+        int src_linesize = linesize;

         int mx = (mv->x << 1)&7, mx_idx = subpel_idx[0][mx];

         int my = (mv->y << 1)&7, my_idx = subpel_idx[0][my];

@@ -1198,12 +1197,15 @@ void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst,

         src += y_off * linesize + x_off;

         if (x_off < mx_idx || x_off >= width  - block_w - subpel_idx[2][mx] ||

             y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {

-            s->vdsp.emulated_edge_mc(td->edge_emu_buffer, src - my_idx * linesize - mx_idx, linesize,

-                                     block_w + subpel_idx[1][mx], block_h + subpel_idx[1][my],

+            s->vdsp.emulated_edge_mc(td->edge_emu_buffer, 32,

+                                     src - my_idx * linesize - mx_idx, linesize,

+                                     block_w + subpel_idx[1][mx],

+                                     block_h + subpel_idx[1][my],

                                      x_off - mx_idx, y_off - my_idx, width, height);

-            src = td->edge_emu_buffer + mx_idx + linesize * my_idx;

+            src = td->edge_emu_buffer + mx_idx + 32 * my_idx;

+            src_linesize = 32;

         }

-        mc_func[my_idx][mx_idx](dst, linesize, src, linesize, block_h, mx, my);

+        mc_func[my_idx][mx_idx](dst, linesize, src, src_linesize, block_h, mx, my);

     } else {

         ff_thread_await_progress(ref, (3 + y_off + block_h) >> 4, 0);

         mc_func[0][0](dst, linesize, src + y_off * linesize + x_off, linesize, block_h, 0, 0);

@@ -1248,17 +1250,21 @@ void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1, uint8_t *dst

         ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 3, 0);

         if (x_off < mx_idx || x_off >= width  - block_w - subpel_idx[2][mx] ||

             y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {

-            s->vdsp.emulated_edge_mc(td->edge_emu_buffer, src1 - my_idx * linesize - mx_idx, linesize,

-                                     block_w + subpel_idx[1][mx], block_h + subpel_idx[1][my],

+            s->vdsp.emulated_edge_mc(td->edge_emu_buffer, 32,

+                                     src1 - my_idx * linesize - mx_idx, linesize,

+                                     block_w + subpel_idx[1][mx],

+                                     block_h + subpel_idx[1][my],

                                      x_off - mx_idx, y_off - my_idx, width, height);

-            src1 = td->edge_emu_buffer + mx_idx + linesize * my_idx;

-            mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);

+            src1 = td->edge_emu_buffer + mx_idx + 32 * my_idx;

+            mc_func[my_idx][mx_idx](dst1, linesize, src1, 32, block_h, mx, my);

-            s->vdsp.emulated_edge_mc(td->edge_emu_buffer, src2 - my_idx * linesize - mx_idx, linesize,

-                                     block_w + subpel_idx[1][mx], block_h + subpel_idx[1][my],

+            s->vdsp.emulated_edge_mc(td->edge_emu_buffer, 32,

+                                     src2 - my_idx * linesize - mx_idx, linesize,

+                                     block_w + subpel_idx[1][mx],

+                                     block_h + subpel_idx[1][my],

                                      x_off - mx_idx, y_off - my_idx, width, height);

-            src2 = td->edge_emu_buffer + mx_idx + linesize * my_idx;

-            mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);

+            src2 = td->edge_emu_buffer + mx_idx + 32 * my_idx;

+            mc_func[my_idx][mx_idx](dst2, linesize, src2, 32, block_h, mx, my);

         } else {

             mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);

             mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);

@@ -1944,10 +1950,6 @@ int ff_vp8_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

     s->linesize   = curframe->tf.f->linesize[0];

     s->uvlinesize = curframe->tf.f->linesize[1];

-    if (!s->thread_data[0].edge_emu_buffer)

-        for (i = 0; i < MAX_THREADS; i++)

-            s->thread_data[i].edge_emu_buffer = av_malloc(21*s->linesize);

-

     memset(s->top_nnz, 0, s->mb_width*sizeof(*s->top_nnz));

     /* Zero macroblock structures for top/top-left prediction from outside the frame. */

     if (!s->mb_layout)

@@ -122,7 +122,7 @@ typedef struct VP8ThreadData {

 #endif

     int thread_mb_pos; // (mb_y << 16) | (mb_x & 0xFFFF)

     int wait_mb_pos; // What the current thread is waiting on.

-    uint8_t *edge_emu_buffer;

+    DECLARE_ALIGNED(16, uint8_t, edge_emu_buffer)[21*32];

     VP8FilterStrength *filter_strength;

 } VP8ThreadData;

@@ -119,8 +119,10 @@ void ff_mspel_motion(MpegEncContext *s,

         if(src_x<1 || src_y<1 || src_x + 17  >= s->h_edge_pos

                               || src_y + h+1 >= v_edge_pos){

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr - 1 - s->linesize, s->linesize, 19, 19,

-                             src_x-1, src_y-1, s->h_edge_pos, s->v_edge_pos);

+            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,

+                                     ptr - 1 - s->linesize, s->linesize, 19, 19,

+                                     src_x-1, src_y-1,

+                                     s->h_edge_pos, s->v_edge_pos);

             ptr= s->edge_emu_buffer + 1 + s->linesize;

             emu=1;

         }

@@ -159,16 +161,18 @@ void ff_mspel_motion(MpegEncContext *s,

     offset = (src_y * uvlinesize) + src_x;

     ptr = ref_picture[1] + offset;

     if(emu){

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,

-                         src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize,

+                                 ptr, s->uvlinesize, 9, 9, src_x, src_y,

+                                 s->h_edge_pos>>1, s->v_edge_pos>>1);

         ptr= s->edge_emu_buffer;

     }

     pix_op[1][dxy](dest_cb, ptr, uvlinesize, h >> 1);

     ptr = ref_picture[2] + offset;

     if(emu){

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,

-                         src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);

+        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize,

+                                 ptr, s->uvlinesize, 9, 9, src_x, src_y,

+                                 s->h_edge_pos>>1, s->v_edge_pos>>1);

         ptr= s->edge_emu_buffer;

     }

     pix_op[1][dxy](dest_cr, ptr, uvlinesize, h >> 1);

@@ -405,8 +405,9 @@ void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,

     }

 }

-typedef void emulated_edge_mc_func(uint8_t *dst, const uint8_t *src,

-                                   ptrdiff_t linesize, int block_w, int block_h,

+typedef void emulated_edge_mc_func(uint8_t *dst, ptrdiff_t dst_stride,

+                                   const uint8_t *src, ptrdiff_t src_linesize,

+                                   int block_w, int block_h,

                                    int src_x, int src_y, int w, int h);

 static av_always_inline void gmc(uint8_t *dst, uint8_t *src,

@@ -454,7 +455,7 @@ static av_always_inline void gmc(uint8_t *dst, uint8_t *src,

     src += ix + iy * stride;

     if (need_emu) {

-        emu_edge_fn(edge_buf, src, stride, w + 1, h + 1, ix, iy, width, height);

+        emu_edge_fn(edge_buf, stride, src, stride, w + 1, h + 1, ix, iy, width, height);

         src = edge_buf;

     }

@@ -23,576 +23,394 @@

 SECTION .text

-; void ff_emu_edge_core(uint8_t *buf, const uint8_t *src, x86_reg linesize,

-;                       x86_reg start_y, x86_reg end_y, x86_reg block_h,

-;                       x86_reg start_x, x86_reg end_x, x86_reg block_w);

-;

-; The actual function itself is below. It basically wraps a very simple

-; w = end_x - start_x

-; if (w) {

-;   if (w > 22) {

-;     jump to the slow loop functions

-;   } else {

-;     jump to the fast loop functions

-;   }

-; }

-;

-; ... and then the same for left/right extend also. See below for loop

-; function implementations. Fast are fixed-width, slow is variable-width

-

-%macro EMU_EDGE_FUNC 0

-%if ARCH_X86_64

-%define w_reg r7

-cglobal emu_edge_core, 6, 9, 1

-    mov         r8, r5          ; save block_h

-%else

-%define w_reg r6

-cglobal emu_edge_core, 2, 7, 0

-    mov         r4, r4m         ; end_y

-    mov         r5, r5m         ; block_h

-%endif

-

-    ; start with vertical extend (top/bottom) and body pixel copy

-    mov      w_reg, r7m

-    sub      w_reg, r6m         ; w = start_x - end_x

-    sub         r5, r4

-%if ARCH_X86_64

-    sub         r4, r3

-%else

-    sub         r4, dword r3m

-%endif

-    cmp      w_reg, 22

-    jg .slow_v_extend_loop

-%if ARCH_X86_32

-    mov         r2, r2m         ; linesize

-%endif

-    sal      w_reg, 7           ; w * 128

-%ifdef PIC

-    lea        rax, [.emuedge_v_extend_1 - (.emuedge_v_extend_2 - .emuedge_v_extend_1)]

-    add      w_reg, rax

-%else

-    lea      w_reg, [.emuedge_v_extend_1 - (.emuedge_v_extend_2 - .emuedge_v_extend_1)+w_reg]

-%endif

-    call     w_reg              ; fast top extend, body copy and bottom extend

-.v_extend_end:

+; slow vertical extension loop function. Works with variable-width, and

+; does per-line reading/writing of source data

+

+%macro V_COPY_ROW 2 ; type (top/body/bottom), h

+.%1_y_loop:                                     ; do {

+    mov              wq, r7mp                   ;   initialize w (r7mp = wmp)

+.%1_x_loop:                                     ;   do {

+    movu             m0, [srcq+wq]              ;     m0 = read($mmsize)

+    movu      [dstq+wq], m0                     ;     write(m0, $mmsize)

+    add              wq, mmsize                 ;     w -= $mmsize

+    cmp              wq, -mmsize                ;   } while (w > $mmsize);

+    jl .%1_x_loop

+    movu             m0, [srcq-mmsize]          ;     m0 = read($mmsize)

+    movu  [dstq-mmsize], m0                     ;     write(m0, $mmsize)

+%ifidn %1, body                                 ;   if ($type == body) {

+    add            srcq, src_strideq            ;     src += src_stride

+%endif                                          ;   }

+    add            dstq, dst_strideq            ;   dst += dst_stride

+    dec              %2                         ; } while (--$h);

+    jnz .%1_y_loop

+%endmacro

-    ; horizontal extend (left/right)

-    mov      w_reg, r6m         ; start_x

-    sub         r0, w_reg

+%macro vvar_fn 0

+; .----. <- zero

+; |    |    <- top is copied from first line in body of source

+; |----| <- start_y

+; |    |    <- body is copied verbatim (line-by-line) from source

+; |----| <- end_y

+; |    |    <- bottom is copied from last line in body of source

+; '----' <- bh

 %if ARCH_X86_64

-    mov         r3, r0          ; backup of buf+block_h*linesize

-    mov         r5, r8

-%else

-    mov        r0m, r0          ; backup of buf+block_h*linesize

-    mov         r5, r5m

+cglobal emu_edge_vvar, 7, 8, 1, dst, dst_stride, src, src_stride, \

+                                start_y, end_y, bh, w

+%else ; x86-32

+cglobal emu_edge_vvar, 1, 6, 1, dst, src, start_y, end_y, bh, w

+%define src_strideq r3mp

+%define dst_strideq r1mp

+    mov            srcq, r2mp

+    mov        start_yq, r4mp

+    mov          end_yq, r5mp

+    mov             bhq, r6mp

 %endif

-    test     w_reg, w_reg

-    jz .right_extend

-    cmp      w_reg, 22

-    jg .slow_left_extend_loop

-    mov         r1, w_reg

-    dec      w_reg

-    ; FIXME we can do a if size == 1 here if that makes any speed difference, test me

-    sar      w_reg, 1

-    sal      w_reg, 6

-    ; r0=buf+block_h*linesize,r7(64)/r6(32)=start_x offset for funcs

-    ; r6(rax)/r3(ebx)=val,r2=linesize,r1=start_x,r5=block_h

-%ifdef PIC

-    lea        rax, [.emuedge_extend_left_2]

-    add      w_reg, rax

-%else

-    lea      w_reg, [.emuedge_extend_left_2+w_reg]

-%endif

-    call     w_reg

+    sub             bhq, end_yq                 ; bh    -= end_q

+    sub          end_yq, start_yq               ; end_q -= start_q

+    add            srcq, r7mp                   ; (r7mp = wmp)

+    add            dstq, r7mp                   ; (r7mp = wmp)

+    neg            r7mp                         ; (r7mp = wmp)

+    test       start_yq, start_yq               ; if (start_q) {

+    jz .body

+    V_COPY_ROW      top, start_yq               ;   v_copy_row(top, start_yq)

+.body:                                          ; }

+    V_COPY_ROW     body, end_yq                 ; v_copy_row(body, end_yq)

+    test            bhq, bhq                    ; if (bh) {

+    jz .end

+    sub            srcq, src_strideq            ;   src -= src_stride

+    V_COPY_ROW   bottom, bhq                    ;   v_copy_row(bottom, bh)

+.end:                                           ; }