Make argument order uniform between bitmap functions

7 files changed, 71 insertions, 74 deletions

diff --git a/libass/ass_bitmap.c b/libass/ass_bitmap.c
index 5c02b25..d3186b4 100644
--- a/libass/ass_bitmap.c
+++ b/libass/ass_bitmap.c
@@ -84,13 +84,13 @@ void ass_synth_blur(const BitmapEngine *engine, Bitmap *bm,
     ptrdiff_t stride = bm->stride;
     uint8_t *buf = bm->buffer;
     if (--be) {
-        be_blur_pre(buf, w, h, stride);
+        be_blur_pre(buf, stride, w, h);
         do {
-            engine->be_blur(buf, w, h, stride, tmp);
+            engine->be_blur(buf, stride, w, h, tmp);
         } while (--be);
-        be_blur_post(buf, w, h, stride);
+        be_blur_post(buf, stride, w, h);
     }
-    engine->be_blur(buf, w, h, stride, tmp);
+    engine->be_blur(buf, stride, w, h, tmp);
     ass_aligned_free(tmp);
 }
 
@@ -257,11 +257,11 @@ void shift_bitmap(Bitmap *bm, int shift_x, int shift_y)
  * This blur is the same as the one employed by vsfilter.
  * Pure C implementation.
  */
-void ass_be_blur_c(uint8_t *buf, intptr_t w, intptr_t h,
-                   intptr_t stride, uint16_t *tmp)
+void ass_be_blur_c(uint8_t *buf, intptr_t stride,
+                   intptr_t width, intptr_t height, uint16_t *tmp)
 {
     uint16_t *col_pix_buf = tmp;
-    uint16_t *col_sum_buf = tmp + w;
+    uint16_t *col_sum_buf = tmp + width;
     unsigned x, y, old_pix, old_sum, temp1, temp2;
     uint8_t *src, *dst;
     y = 0;
@@ -272,7 +272,7 @@ void ass_be_blur_c(uint8_t *buf, intptr_t w, intptr_t h,
         x = 1;
         old_pix = src[x-1];
         old_sum = old_pix;
-        for ( ; x < w; x++) {
+        for ( ; x < width; x++) {
             temp1 = src[x];
             temp2 = old_pix + temp1;
             old_pix = temp1;
@@ -286,14 +286,14 @@ void ass_be_blur_c(uint8_t *buf, intptr_t w, intptr_t h,
         col_sum_buf[x-1] = temp1;
     }
 
-    for (y++; y < h; y++) {
+    for (y++; y < height; y++) {
         src=buf+y*stride;
         dst=buf+(y-1)*stride;
 
         x = 1;
         old_pix = src[x-1];
         old_sum = old_pix;
-        for ( ; x < w; x++) {
+        for ( ; x < width; x++) {
             temp1 = src[x];
             temp2 = old_pix + temp1;
             old_pix = temp1;
@@ -314,16 +314,16 @@ void ass_be_blur_c(uint8_t *buf, intptr_t w, intptr_t h,
 
     {
         dst=buf+(y-1)*stride;
-        for (x = 0; x < w; x++)
+        for (x = 0; x < width; x++)
             dst[x] = (col_sum_buf[x] + col_pix_buf[x]) >> 4;
     }
 }
 
-void be_blur_pre(uint8_t *buf, intptr_t w, intptr_t h, intptr_t stride)
+void be_blur_pre(uint8_t *buf, intptr_t stride, intptr_t width, intptr_t height)
 {
-    for (int y = 0; y < h; ++y)
+    for (int y = 0; y < height; ++y)
     {
-        for (int x = 0; x < w; ++x)
+        for (int x = 0; x < width; ++x)
         {
             // This is equivalent to (value * 64 + 127) / 255 for all
             // values from 0 to 256 inclusive. Assist vectorizing
@@ -334,11 +334,11 @@ void be_blur_pre(uint8_t *buf, intptr_t w, intptr_t h, intptr_t stride)
     }
 }
 
-void be_blur_post(uint8_t *buf, intptr_t w, intptr_t h, intptr_t stride)
+void be_blur_post(uint8_t *buf, intptr_t stride, intptr_t width, intptr_t height)
 {
-    for (int y = 0; y < h; ++y)
+    for (int y = 0; y < height; ++y)
     {
-        for (int x = 0; x < w; ++x)
+        for (int x = 0; x < width; ++x)
         {
             // This is equivalent to (value * 255 + 32) / 64 for all values
             // from 0 to 96 inclusive, and we only care about 0 to 64.
@@ -381,7 +381,7 @@ int be_padding(int be)
  */
 void ass_add_bitmaps_c(uint8_t *dst, intptr_t dst_stride,
                        uint8_t *src, intptr_t src_stride,
-                       intptr_t height, intptr_t width)
+                       intptr_t width, intptr_t height)
 {
     unsigned out;
     uint8_t* end = dst + dst_stride * height;
@@ -397,7 +397,7 @@ void ass_add_bitmaps_c(uint8_t *dst, intptr_t dst_stride,
 
 void ass_sub_bitmaps_c(uint8_t *dst, intptr_t dst_stride,
                        uint8_t *src, intptr_t src_stride,
-                       intptr_t height, intptr_t width)
+                       intptr_t width, intptr_t height)
 {
     short out;
     uint8_t* end = dst + dst_stride * height;
@@ -414,11 +414,11 @@ void ass_sub_bitmaps_c(uint8_t *dst, intptr_t dst_stride,
 void ass_mul_bitmaps_c(uint8_t *dst, intptr_t dst_stride,
                        uint8_t *src1, intptr_t src1_stride,
                        uint8_t *src2, intptr_t src2_stride,
-                       intptr_t w, intptr_t h)
+                       intptr_t width, intptr_t height)
 {
-    uint8_t* end = src1 + src1_stride * h;
+    uint8_t* end = src1 + src1_stride * height;
     while (src1 < end) {
-        for (unsigned x = 0; x < w; ++x) {
+        for (unsigned x = 0; x < width; ++x) {
             dst[x] = (src1[x] * src2[x] + 255) >> 8;
         }
         dst  += dst_stride;
diff --git a/libass/ass_bitmap.h b/libass/ass_bitmap.h
index 99052e4..d5f1c35 100644
--- a/libass/ass_bitmap.h
+++ b/libass/ass_bitmap.h
@@ -37,14 +37,14 @@ typedef void (*FillGenericTileFunc)(uint8_t *buf, ptrdiff_t stride,
 
 typedef void (*BitmapBlendFunc)(uint8_t *dst, intptr_t dst_stride,
                                 uint8_t *src, intptr_t src_stride,
-                                intptr_t height, intptr_t width);
+                                intptr_t width, intptr_t height);
 typedef void (*BitmapMulFunc)(uint8_t *dst, intptr_t dst_stride,
                               uint8_t *src1, intptr_t src1_stride,
                               uint8_t *src2, intptr_t src2_stride,
                               intptr_t width, intptr_t height);
 
-typedef void (*BeBlurFunc)(uint8_t *buf, intptr_t w, intptr_t h,
-                           intptr_t stride, uint16_t *tmp);
+typedef void (*BeBlurFunc)(uint8_t *buf, intptr_t stride,
+                           intptr_t width, intptr_t height, uint16_t *tmp);
 
 // intermediate bitmaps represented as sets of verical stripes of int16_t[alignment / 2]
 typedef void (*Convert8to16Func)(int16_t *dst, const uint8_t *src, ptrdiff_t src_stride,
@@ -107,10 +107,8 @@ void ass_synth_blur(const BitmapEngine *engine, Bitmap *bm,
                     int be, double blur_r2);
 
 int be_padding(int be);
-void be_blur_pre(uint8_t *buf, intptr_t w,
-                 intptr_t h, intptr_t stride);
-void be_blur_post(uint8_t *buf, intptr_t w,
-                  intptr_t h, intptr_t stride);
+void be_blur_pre(uint8_t *buf, intptr_t stride, intptr_t width, intptr_t height);
+void be_blur_post(uint8_t *buf, intptr_t stride, intptr_t width, intptr_t height);
 bool ass_gaussian_blur(const BitmapEngine *engine, Bitmap *bm, double r2);
 void shift_bitmap(Bitmap *bm, int shift_x, int shift_y);
 void fix_outline(Bitmap *bm_g, Bitmap *bm_o);
diff --git a/libass/ass_func_template.h b/libass/ass_func_template.h
index 4c28777..f986295 100644
--- a/libass/ass_func_template.h
+++ b/libass/ass_func_template.h
@@ -33,17 +33,17 @@ void DECORATE(fill_generic_tile32)(uint8_t *buf, ptrdiff_t stride,
 
 void DECORATE(add_bitmaps)(uint8_t *dst, intptr_t dst_stride,
                            uint8_t *src, intptr_t src_stride,
-                           intptr_t height, intptr_t width);
+                           intptr_t width, intptr_t height);
 void DECORATE(sub_bitmaps)(uint8_t *dst, intptr_t dst_stride,
                            uint8_t *src, intptr_t src_stride,
-                           intptr_t height, intptr_t width);
+                           intptr_t width, intptr_t height);
 void DECORATE(mul_bitmaps)(uint8_t *dst, intptr_t dst_stride,
                            uint8_t *src1, intptr_t src1_stride,
                            uint8_t *src2, intptr_t src2_stride,
                            intptr_t width, intptr_t height);
 
-void DECORATE(be_blur)(uint8_t *buf, intptr_t w, intptr_t h,
-                       intptr_t stride, uint16_t *tmp);
+void DECORATE(be_blur)(uint8_t *buf, intptr_t stride,
+                       intptr_t width, intptr_t height, uint16_t *tmp);
 
 void DECORATE(stripe_unpack)(int16_t *dst, const uint8_t *src, ptrdiff_t src_stride,
                              uintptr_t width, uintptr_t height);
diff --git a/libass/ass_rasterizer.c b/libass/ass_rasterizer.c
index 5310258..1edec57 100644
--- a/libass/ass_rasterizer.c
+++ b/libass/ass_rasterizer.c
@@ -675,7 +675,7 @@ static bool rasterizer_fill_level(const BitmapEngine *engine, RasterizerData *rs
             engine->fill_halfplane(rst->tile, width, line1->a, line1->b, line1->c,
                                    flags1 & FLAG_REVERSE ? -line1->scale : line1->scale);
         // XXX: better to use max instead of add
-        engine->add_bitmaps(buf, stride, rst->tile, width, height, width);
+        engine->add_bitmaps(buf, stride, rst->tile, width, width, height);
         rst->size[index] = offs;
         return true;
     }
diff --git a/libass/ass_render.c b/libass/ass_render.c
index 05a0604..8aad294 100644
--- a/libass/ass_render.c
+++ b/libass/ass_render.c
@@ -731,7 +731,7 @@ static void blend_vector_clip(ASS_Renderer *render_priv, ASS_Image *head)
             memcpy(nbuffer, abuffer, ((ah - 1) * as) + aw);
             render_priv->engine->sub_bitmaps(nbuffer + atop * as + aleft, as,
                                              bbuffer + btop * bs + bleft, bs,
-                                             h, w);
+                                             w, h);
         } else {
             // Regular clip
             if (ax + aw < bx || ay + ah < by || ax > bx + bw ||
@@ -2508,7 +2508,7 @@ size_t ass_composite_construct(void *key, void *value, void *priv)
             unsigned char *buf = dst->buffer + y * dst->stride + x;
             render_priv->engine->add_bitmaps(buf, dst->stride,
                                              src->buffer, src->stride,
-                                             src->h, src->w);
+                                             src->w, src->h);
         }
     }
     if (!bord && n_bm_o == 1) {
@@ -2533,7 +2533,7 @@ size_t ass_composite_construct(void *key, void *value, void *priv)
             unsigned char *buf = dst->buffer + y * dst->stride + x;
             render_priv->engine->add_bitmaps(buf, dst->stride,
                                              src->buffer, src->stride,
-                                             src->h, src->w);
+                                             src->w, src->h);
         }
     }
 
diff --git a/libass/x86/be_blur.asm b/libass/x86/be_blur.asm
index 068ee34..3f5bcb3 100644
--- a/libass/x86/be_blur.asm
+++ b/libass/x86/be_blur.asm
@@ -24,19 +24,19 @@ SECTION .text
 
 ;------------------------------------------------------------------------------
 ; BE_BLUR
-; void be_blur(uint8_t *buf, intptr_t width, intptr_t height,
-;              intptr_t stride, uint16_t *tmp);
+; void be_blur(uint8_t *buf, intptr_t stride,
+;              intptr_t width, intptr_t height, uint16_t *tmp);
 ;------------------------------------------------------------------------------
 
 %macro BE_BLUR 0
 cglobal be_blur, 5,7,8
-    lea r0, [r0 + r1]
-    lea r4, [r4 + 4 * r1]
+    lea r0, [r0 + r2]
+    lea r4, [r4 + 4 * r2]
     mov r6, r0
-    neg r1
-    mov r5, r1
-    imul r2, r3
-    add r2, r0
+    neg r2
+    mov r5, r2
+    imul r3, r1
+    add r3, r0
     pxor m6, m6
 
     mova m3, [r0 + r5]
@@ -109,12 +109,12 @@ cglobal be_blur, 5,7,8
     mova [r4 + 4 * r5 - 2 * mmsize], m3
     mova [r4 + 4 * r5 - mmsize], m3
 
-    add r0, r3
-    cmp r0, r2
+    add r0, r1
+    cmp r0, r3
     jge .last_row
 
 .height_loop:
-    mov r5, r1
+    mov r5, r2
     mova m3, [r0 + r5]
 %if mmsize == 32
     vpermq m3, m3, q3120
@@ -204,13 +204,13 @@ cglobal be_blur, 5,7,8
 %endif
     mova [r6 + r5 - mmsize], m2
 
-    add r0, r3
-    add r6, r3
-    cmp r0, r2
+    add r0, r1
+    add r6, r1
+    cmp r0, r3
     jl .height_loop
 
 .last_row:
-    mov r5, r1
+    mov r5, r2
 .last_width_loop:
     mova m2, [r4 + 4 * r5]
     paddw m2, [r4 + 4 * r5 + mmsize]
diff --git a/libass/x86/blend_bitmaps.asm b/libass/x86/blend_bitmaps.asm
index 0ca93d1..7bde78a 100644
--- a/libass/x86/blend_bitmaps.asm
+++ b/libass/x86/blend_bitmaps.asm
@@ -32,10 +32,10 @@ SECTION .text
 ; BLEND_BITMAPS 1:add/sub
 ; void add_bitmaps(uint8_t *dst, intptr_t dst_stride,
 ;                  uint8_t *src, intptr_t src_stride,
-;                  intptr_t height, intptr_t width);
+;                  intptr_t width, intptr_t height);
 ; void sub_bitmaps(uint8_t *dst, intptr_t dst_stride,
 ;                  uint8_t *src, intptr_t src_stride,
-;                  intptr_t height, intptr_t width);
+;                  intptr_t width, intptr_t height);
 ;------------------------------------------------------------------------------
 
 %macro BLEND_BITMAPS 1
@@ -43,40 +43,39 @@ SECTION .text
 cglobal %1_bitmaps, 6,8,3
     DECLARE_REG_TMP 7
 %else
-cglobal %1_bitmaps, 4,7,3
-    DECLARE_REG_TMP 4
-    mov r5, r5m
+cglobal %1_bitmaps, 5,7,3
+    DECLARE_REG_TMP 5
 %endif
-    lea r0, [r0 + r5]
-    lea r2, [r2 + r5]
-    neg r5
-    mov r6, r5
-    and r5, mmsize - 1
+    lea r0, [r0 + r4]
+    lea r2, [r2 + r4]
+    neg r4
+    mov r6, r4
+    and r4, mmsize - 1
     lea t0, [edge_mask]
-    movu m2, [t0 + r5 - mmsize]
+    movu m2, [t0 + r4 - mmsize]
 %if !ARCH_X86_64
-    mov r4, r4m
+    mov r5, r5m
 %endif
-    imul r4, r3
-    add r4, r2
-    mov r5, r6
+    imul r5, r3
+    add r5, r2
+    mov r4, r6
     jmp .loop_entry
 
 .width_loop:
     p%1usb m0, m1
-    movu [r0 + r5 - mmsize], m0
+    movu [r0 + r4 - mmsize], m0
 .loop_entry:
-    movu m0, [r0 + r5]
-    movu m1, [r2 + r5]
-    add r5, mmsize
+    movu m0, [r0 + r4]
+    movu m1, [r2 + r4]
+    add r4, mmsize
     jnc .width_loop
     pand m1, m2
     p%1usb m0, m1
-    movu [r0 + r5 - mmsize], m0
+    movu [r0 + r4 - mmsize], m0
     add r0, r1
     add r2, r3
-    mov r5, r6
-    cmp r2, r4
+    mov r4, r6
+    cmp r2, r5
     jl .loop_entry
     RET
 %endmacro