Ignore:
Timestamp:
Jul 28, 2017 2:51:44 AM (7 years ago)
Author:
nanang
Message:

Re #2004: Update libyuv version from libyuv git master repo dated 27 July 2017, the compile errors on old gcc versions issue persists though.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • pjproject/trunk/third_party/yuv/source/scale_common.cc

    r5358 r5633  
    2929 
    3030// CPU agnostic row functions 
    31 void ScaleRowDown2_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    32                      uint8* dst, int dst_width) { 
    33   int x; 
     31void ScaleRowDown2_C(const uint8* src_ptr, 
     32                     ptrdiff_t src_stride, 
     33                     uint8* dst, 
     34                     int dst_width) { 
     35  int x; 
     36  (void)src_stride; 
    3437  for (x = 0; x < dst_width - 1; x += 2) { 
    3538    dst[0] = src_ptr[1]; 
    … …  
    4346} 
    4447 
    45 void ScaleRowDown2_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    46                         uint16* dst, int dst_width) { 
    47   int x; 
     48void ScaleRowDown2_16_C(const uint16* src_ptr, 
     49                        ptrdiff_t src_stride, 
     50                        uint16* dst, 
     51                        int dst_width) { 
     52  int x; 
     53  (void)src_stride; 
    4854  for (x = 0; x < dst_width - 1; x += 2) { 
    4955    dst[0] = src_ptr[1]; 
    … …  
    5763} 
    5864 
    59 void ScaleRowDown2Linear_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    60                            uint8* dst, int dst_width) { 
     65void ScaleRowDown2Linear_C(const uint8* src_ptr, 
     66                           ptrdiff_t src_stride, 
     67                           uint8* dst, 
     68                           int dst_width) { 
    6169  const uint8* s = src_ptr; 
    6270  int x; 
     71  (void)src_stride; 
    6372  for (x = 0; x < dst_width - 1; x += 2) { 
    6473    dst[0] = (s[0] + s[1] + 1) >> 1; 
    … …  
    7281} 
    7382 
    74 void ScaleRowDown2Linear_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    75                               uint16* dst, int dst_width) { 
     83void ScaleRowDown2Linear_16_C(const uint16* src_ptr, 
     84                              ptrdiff_t src_stride, 
     85                              uint16* dst, 
     86                              int dst_width) { 
    7687  const uint16* s = src_ptr; 
    7788  int x; 
     89  (void)src_stride; 
    7890  for (x = 0; x < dst_width - 1; x += 2) { 
    7991    dst[0] = (s[0] + s[1] + 1) >> 1; 
    … …  
    8799} 
    88100 
    89 void ScaleRowDown2Box_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    90                         uint8* dst, int dst_width) { 
     101void ScaleRowDown2Box_C(const uint8* src_ptr, 
     102                        ptrdiff_t src_stride, 
     103                        uint8* dst, 
     104                        int dst_width) { 
    91105  const uint8* s = src_ptr; 
    92106  const uint8* t = src_ptr + src_stride; 
    … …  
    104118} 
    105119 
    106 void ScaleRowDown2Box_Odd_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    107                             uint8* dst, int dst_width) { 
     120void ScaleRowDown2Box_Odd_C(const uint8* src_ptr, 
     121                            ptrdiff_t src_stride, 
     122                            uint8* dst, 
     123                            int dst_width) { 
    108124  const uint8* s = src_ptr; 
    109125  const uint8* t = src_ptr + src_stride; 
    … …  
    126142} 
    127143 
    128 void ScaleRowDown2Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    129                            uint16* dst, int dst_width) { 
     144void ScaleRowDown2Box_16_C(const uint16* src_ptr, 
     145                           ptrdiff_t src_stride, 
     146                           uint16* dst, 
     147                           int dst_width) { 
    130148  const uint16* s = src_ptr; 
    131149  const uint16* t = src_ptr + src_stride; 
    … …  
    143161} 
    144162 
    145 void ScaleRowDown4_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    146                      uint8* dst, int dst_width) { 
    147   int x; 
     163void ScaleRowDown4_C(const uint8* src_ptr, 
     164                     ptrdiff_t src_stride, 
     165                     uint8* dst, 
     166                     int dst_width) { 
     167  int x; 
     168  (void)src_stride; 
    148169  for (x = 0; x < dst_width - 1; x += 2) { 
    149170    dst[0] = src_ptr[2]; 
    … …  
    157178} 
    158179 
    159 void ScaleRowDown4_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    160                         uint16* dst, int dst_width) { 
    161   int x; 
     180void ScaleRowDown4_16_C(const uint16* src_ptr, 
     181                        ptrdiff_t src_stride, 
     182                        uint16* dst, 
     183                        int dst_width) { 
     184  int x; 
     185  (void)src_stride; 
    162186  for (x = 0; x < dst_width - 1; x += 2) { 
    163187    dst[0] = src_ptr[2]; 
    … …  
    171195} 
    172196 
    173 void ScaleRowDown4Box_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    174                         uint8* dst, int dst_width) { 
     197void ScaleRowDown4Box_C(const uint8* src_ptr, 
     198                        ptrdiff_t src_stride, 
     199                        uint8* dst, 
     200                        int dst_width) { 
    175201  intptr_t stride = src_stride; 
    176202  int x; 
    177203  for (x = 0; x < dst_width - 1; x += 2) { 
    178204    dst[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[3] + 
    179              src_ptr[stride + 0] + src_ptr[stride + 1] + 
    180              src_ptr[stride + 2] + src_ptr[stride + 3] + 
    181              src_ptr[stride * 2 + 0] + src_ptr[stride * 2 + 1] + 
    182              src_ptr[stride * 2 + 2] + src_ptr[stride * 2 + 3] + 
    183              src_ptr[stride * 3 + 0] + src_ptr[stride * 3 + 1] + 
    184              src_ptr[stride * 3 + 2] + src_ptr[stride * 3 + 3] + 
    185              8) >> 4; 
     205              src_ptr[stride + 0] + src_ptr[stride + 1] + src_ptr[stride + 2] + 
     206              src_ptr[stride + 3] + src_ptr[stride * 2 + 0] + 
     207              src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2] + 
     208              src_ptr[stride * 2 + 3] + src_ptr[stride * 3 + 0] + 
     209              src_ptr[stride * 3 + 1] + src_ptr[stride * 3 + 2] + 
     210              src_ptr[stride * 3 + 3] + 8) >> 
     211             4; 
    186212    dst[1] = (src_ptr[4] + src_ptr[5] + src_ptr[6] + src_ptr[7] + 
    187              src_ptr[stride + 4] + src_ptr[stride + 5] + 
    188              src_ptr[stride + 6] + src_ptr[stride + 7] + 
    189              src_ptr[stride * 2 + 4] + src_ptr[stride * 2 + 5] + 
    190              src_ptr[stride * 2 + 6] + src_ptr[stride * 2 + 7] + 
    191              src_ptr[stride * 3 + 4] + src_ptr[stride * 3 + 5] + 
    192              src_ptr[stride * 3 + 6] + src_ptr[stride * 3 + 7] + 
    193              8) >> 4; 
     213              src_ptr[stride + 4] + src_ptr[stride + 5] + src_ptr[stride + 6] + 
     214              src_ptr[stride + 7] + src_ptr[stride * 2 + 4] + 
     215              src_ptr[stride * 2 + 5] + src_ptr[stride * 2 + 6] + 
     216              src_ptr[stride * 2 + 7] + src_ptr[stride * 3 + 4] + 
     217              src_ptr[stride * 3 + 5] + src_ptr[stride * 3 + 6] + 
     218              src_ptr[stride * 3 + 7] + 8) >> 
     219             4; 
    194220    dst += 2; 
    195221    src_ptr += 8; 
    … …  
    197223  if (dst_width & 1) { 
    198224    dst[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[3] + 
    199              src_ptr[stride + 0] + src_ptr[stride + 1] + 
    200              src_ptr[stride + 2] + src_ptr[stride + 3] + 
    201              src_ptr[stride * 2 + 0] + src_ptr[stride * 2 + 1] + 
    202              src_ptr[stride * 2 + 2] + src_ptr[stride * 2 + 3] + 
    203              src_ptr[stride * 3 + 0] + src_ptr[stride * 3 + 1] + 
    204              src_ptr[stride * 3 + 2] + src_ptr[stride * 3 + 3] + 
    205              8) >> 4; 
    206   } 
    207 } 
    208  
    209 void ScaleRowDown4Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    210                            uint16* dst, int dst_width) { 
     225              src_ptr[stride + 0] + src_ptr[stride + 1] + src_ptr[stride + 2] + 
     226              src_ptr[stride + 3] + src_ptr[stride * 2 + 0] + 
     227              src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2] + 
     228              src_ptr[stride * 2 + 3] + src_ptr[stride * 3 + 0] + 
     229              src_ptr[stride * 3 + 1] + src_ptr[stride * 3 + 2] + 
     230              src_ptr[stride * 3 + 3] + 8) >> 
     231             4; 
     232  } 
     233} 
     234 
     235void ScaleRowDown4Box_16_C(const uint16* src_ptr, 
     236                           ptrdiff_t src_stride, 
     237                           uint16* dst, 
     238                           int dst_width) { 
    211239  intptr_t stride = src_stride; 
    212240  int x; 
    213241  for (x = 0; x < dst_width - 1; x += 2) { 
    214242    dst[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[3] + 
    215              src_ptr[stride + 0] + src_ptr[stride + 1] + 
    216              src_ptr[stride + 2] + src_ptr[stride + 3] + 
    217              src_ptr[stride * 2 + 0] + src_ptr[stride * 2 + 1] + 
    218              src_ptr[stride * 2 + 2] + src_ptr[stride * 2 + 3] + 
    219              src_ptr[stride * 3 + 0] + src_ptr[stride * 3 + 1] + 
    220              src_ptr[stride * 3 + 2] + src_ptr[stride * 3 + 3] + 
    221              8) >> 4; 
     243              src_ptr[stride + 0] + src_ptr[stride + 1] + src_ptr[stride + 2] + 
     244              src_ptr[stride + 3] + src_ptr[stride * 2 + 0] + 
     245              src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2] + 
     246              src_ptr[stride * 2 + 3] + src_ptr[stride * 3 + 0] + 
     247              src_ptr[stride * 3 + 1] + src_ptr[stride * 3 + 2] + 
     248              src_ptr[stride * 3 + 3] + 8) >> 
     249             4; 
    222250    dst[1] = (src_ptr[4] + src_ptr[5] + src_ptr[6] + src_ptr[7] + 
    223              src_ptr[stride + 4] + src_ptr[stride + 5] + 
    224              src_ptr[stride + 6] + src_ptr[stride + 7] + 
    225              src_ptr[stride * 2 + 4] + src_ptr[stride * 2 + 5] + 
    226              src_ptr[stride * 2 + 6] + src_ptr[stride * 2 + 7] + 
    227              src_ptr[stride * 3 + 4] + src_ptr[stride * 3 + 5] + 
    228              src_ptr[stride * 3 + 6] + src_ptr[stride * 3 + 7] + 
    229              8) >> 4; 
     251              src_ptr[stride + 4] + src_ptr[stride + 5] + src_ptr[stride + 6] + 
     252              src_ptr[stride + 7] + src_ptr[stride * 2 + 4] + 
     253              src_ptr[stride * 2 + 5] + src_ptr[stride * 2 + 6] + 
     254              src_ptr[stride * 2 + 7] + src_ptr[stride * 3 + 4] + 
     255              src_ptr[stride * 3 + 5] + src_ptr[stride * 3 + 6] + 
     256              src_ptr[stride * 3 + 7] + 8) >> 
     257             4; 
    230258    dst += 2; 
    231259    src_ptr += 8; 
    … …  
    233261  if (dst_width & 1) { 
    234262    dst[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[3] + 
    235              src_ptr[stride + 0] + src_ptr[stride + 1] + 
    236              src_ptr[stride + 2] + src_ptr[stride + 3] + 
    237              src_ptr[stride * 2 + 0] + src_ptr[stride * 2 + 1] + 
    238              src_ptr[stride * 2 + 2] + src_ptr[stride * 2 + 3] + 
    239              src_ptr[stride * 3 + 0] + src_ptr[stride * 3 + 1] + 
    240              src_ptr[stride * 3 + 2] + src_ptr[stride * 3 + 3] + 
    241              8) >> 4; 
    242   } 
    243 } 
    244  
    245 void ScaleRowDown34_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    246                       uint8* dst, int dst_width) { 
    247   int x; 
     263              src_ptr[stride + 0] + src_ptr[stride + 1] + src_ptr[stride + 2] + 
     264              src_ptr[stride + 3] + src_ptr[stride * 2 + 0] + 
     265              src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2] + 
     266              src_ptr[stride * 2 + 3] + src_ptr[stride * 3 + 0] + 
     267              src_ptr[stride * 3 + 1] + src_ptr[stride * 3 + 2] + 
     268              src_ptr[stride * 3 + 3] + 8) >> 
     269             4; 
     270  } 
     271} 
     272 
     273void ScaleRowDown34_C(const uint8* src_ptr, 
     274                      ptrdiff_t src_stride, 
     275                      uint8* dst, 
     276                      int dst_width) { 
     277  int x; 
     278  (void)src_stride; 
    248279  assert((dst_width % 3 == 0) && (dst_width > 0)); 
    249280  for (x = 0; x < dst_width; x += 3) { 
    … …  
    256287} 
    257288 
    258 void ScaleRowDown34_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    259                          uint16* dst, int dst_width) { 
    260   int x; 
     289void ScaleRowDown34_16_C(const uint16* src_ptr, 
     290                         ptrdiff_t src_stride, 
     291                         uint16* dst, 
     292                         int dst_width) { 
     293  int x; 
     294  (void)src_stride; 
    261295  assert((dst_width % 3 == 0) && (dst_width > 0)); 
    262296  for (x = 0; x < dst_width; x += 3) { 
    … …  
    270304 
    271305// Filter rows 0 and 1 together, 3 : 1 
    272 void ScaleRowDown34_0_Box_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    273                             uint8* d, int dst_width) { 
     306void ScaleRowDown34_0_Box_C(const uint8* src_ptr, 
     307                            ptrdiff_t src_stride, 
     308                            uint8* d, 
     309                            int dst_width) { 
    274310  const uint8* s = src_ptr; 
    275311  const uint8* t = src_ptr + src_stride; 
    … …  
    292328} 
    293329 
    294 void ScaleRowDown34_0_Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    295                                uint16* d, int dst_width) { 
     330void ScaleRowDown34_0_Box_16_C(const uint16* src_ptr, 
     331                               ptrdiff_t src_stride, 
     332                               uint16* d, 
     333                               int dst_width) { 
    296334  const uint16* s = src_ptr; 
    297335  const uint16* t = src_ptr + src_stride; 
    … …  
    315353 
    316354// Filter rows 1 and 2 together, 1 : 1 
    317 void ScaleRowDown34_1_Box_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    318                             uint8* d, int dst_width) { 
     355void ScaleRowDown34_1_Box_C(const uint8* src_ptr, 
     356                            ptrdiff_t src_stride, 
     357                            uint8* d, 
     358                            int dst_width) { 
    319359  const uint8* s = src_ptr; 
    320360  const uint8* t = src_ptr + src_stride; 
    … …  
    337377} 
    338378 
    339 void ScaleRowDown34_1_Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    340                                uint16* d, int dst_width) { 
     379void ScaleRowDown34_1_Box_16_C(const uint16* src_ptr, 
     380                               ptrdiff_t src_stride, 
     381                               uint16* d, 
     382                               int dst_width) { 
    341383  const uint16* s = src_ptr; 
    342384  const uint16* t = src_ptr + src_stride; 
    … …  
    360402 
    361403// Scales a single row of pixels using point sampling. 
    362 void ScaleCols_C(uint8* dst_ptr, const uint8* src_ptr, 
    363                  int dst_width, int x, int dx) { 
     404void ScaleCols_C(uint8* dst_ptr, 
     405                 const uint8* src_ptr, 
     406                 int dst_width, 
     407                 int x, 
     408                 int dx) { 
    364409  int j; 
    365410  for (j = 0; j < dst_width - 1; j += 2) { 
    … …  
    375420} 
    376421 
    377 void ScaleCols_16_C(uint16* dst_ptr, const uint16* src_ptr, 
    378                     int dst_width, int x, int dx) { 
     422void ScaleCols_16_C(uint16* dst_ptr, 
     423                    const uint16* src_ptr, 
     424                    int dst_width, 
     425                    int x, 
     426                    int dx) { 
    379427  int j; 
    380428  for (j = 0; j < dst_width - 1; j += 2) { 
    … …  
    391439 
    392440// Scales a single row of pixels up by 2x using point sampling. 
    393 void ScaleColsUp2_C(uint8* dst_ptr, const uint8* src_ptr, 
    394                     int dst_width, int x, int dx) { 
    395   int j; 
     441void ScaleColsUp2_C(uint8* dst_ptr, 
     442                    const uint8* src_ptr, 
     443                    int dst_width, 
     444                    int x, 
     445                    int dx) { 
     446  int j; 
     447  (void)x; 
     448  (void)dx; 
    396449  for (j = 0; j < dst_width - 1; j += 2) { 
    397450    dst_ptr[1] = dst_ptr[0] = src_ptr[0]; 
    … …  
    404457} 
    405458 
    406 void ScaleColsUp2_16_C(uint16* dst_ptr, const uint16* src_ptr, 
    407                        int dst_width, int x, int dx) { 
    408   int j; 
     459void ScaleColsUp2_16_C(uint16* dst_ptr, 
     460                       const uint16* src_ptr, 
     461                       int dst_width, 
     462                       int x, 
     463                       int dx) { 
     464  int j; 
     465  (void)x; 
     466  (void)dx; 
    409467  for (j = 0; j < dst_width - 1; j += 2) { 
    410468    dst_ptr[1] = dst_ptr[0] = src_ptr[0]; 
    … …  
    418476 
    419477// (1-f)a + fb can be replaced with a + f(b-a) 
    420 #define BLENDER(a, b, f) (uint8)((int)(a) + \ 
    421     ((int)(f) * ((int)(b) - (int)(a)) >> 16)) 
    422  
    423 void ScaleFilterCols_C(uint8* dst_ptr, const uint8* src_ptr, 
    424                        int dst_width, int x, int dx) { 
     478#if defined(__arm__) || defined(__aarch64__) 
     479#define BLENDER(a, b, f) \ 
     480  (uint8)((int)(a) + ((((int)((f)) * ((int)(b) - (int)(a))) + 0x8000) >> 16)) 
     481#else 
     482// Intel uses 7 bit math with rounding. 
     483#define BLENDER(a, b, f) \ 
     484  (uint8)((int)(a) + (((int)((f) >> 9) * ((int)(b) - (int)(a)) + 0x40) >> 7)) 
     485#endif 
     486 
     487void ScaleFilterCols_C(uint8* dst_ptr, 
     488                       const uint8* src_ptr, 
     489                       int dst_width, 
     490                       int x, 
     491                       int dx) { 
    425492  int j; 
    426493  for (j = 0; j < dst_width - 1; j += 2) { 
    … …  
    445512} 
    446513 
    447 void ScaleFilterCols64_C(uint8* dst_ptr, const uint8* src_ptr, 
    448                          int dst_width, int x32, int dx) { 
     514void ScaleFilterCols64_C(uint8* dst_ptr, 
     515                         const uint8* src_ptr, 
     516                         int dst_width, 
     517                         int x32, 
     518                         int dx) { 
    449519  int64 x = (int64)(x32); 
    450520  int j; 
    … …  
    471541#undef BLENDER 
    472542 
    473 #define BLENDER(a, b, f) (uint16)((int)(a) + \ 
    474     ((int)(f) * ((int)(b) - (int)(a)) >> 16)) 
    475  
    476 void ScaleFilterCols_16_C(uint16* dst_ptr, const uint16* src_ptr, 
    477                        int dst_width, int x, int dx) { 
     543// Same as 8 bit arm blender but return is cast to uint16 
     544#define BLENDER(a, b, f) \ 
     545  (uint16)((int)(a) + ((((int)((f)) * ((int)(b) - (int)(a))) + 0x8000) >> 16)) 
     546 
     547void ScaleFilterCols_16_C(uint16* dst_ptr, 
     548                          const uint16* src_ptr, 
     549                          int dst_width, 
     550                          int x, 
     551                          int dx) { 
    478552  int j; 
    479553  for (j = 0; j < dst_width - 1; j += 2) { 
    … …  
    498572} 
    499573 
    500 void ScaleFilterCols64_16_C(uint16* dst_ptr, const uint16* src_ptr, 
    501                          int dst_width, int x32, int dx) { 
     574void ScaleFilterCols64_16_C(uint16* dst_ptr, 
     575                            const uint16* src_ptr, 
     576                            int dst_width, 
     577                            int x32, 
     578                            int dx) { 
    502579  int64 x = (int64)(x32); 
    503580  int j; 
    … …  
    524601#undef BLENDER 
    525602 
    526 void ScaleRowDown38_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    527                       uint8* dst, int dst_width) { 
    528   int x; 
     603void ScaleRowDown38_C(const uint8* src_ptr, 
     604                      ptrdiff_t src_stride, 
     605                      uint8* dst, 
     606                      int dst_width) { 
     607  int x; 
     608  (void)src_stride; 
    529609  assert(dst_width % 3 == 0); 
    530610  for (x = 0; x < dst_width; x += 3) { 
    … …  
    537617} 
    538618 
    539 void ScaleRowDown38_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    540                          uint16* dst, int dst_width) { 
    541   int x; 
     619void ScaleRowDown38_16_C(const uint16* src_ptr, 
     620                         ptrdiff_t src_stride, 
     621                         uint16* dst, 
     622                         int dst_width) { 
     623  int x; 
     624  (void)src_stride; 
    542625  assert(dst_width % 3 == 0); 
    543626  for (x = 0; x < dst_width; x += 3) { 
    … …  
    553636void ScaleRowDown38_3_Box_C(const uint8* src_ptr, 
    554637                            ptrdiff_t src_stride, 
    555                             uint8* dst_ptr, int dst_width) { 
     638                            uint8* dst_ptr, 
     639                            int dst_width) { 
    556640  intptr_t stride = src_stride; 
    557641  int i; 
    558642  assert((dst_width % 3 == 0) && (dst_width > 0)); 
    559643  for (i = 0; i < dst_width; i += 3) { 
    560     dst_ptr[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + 
    561         src_ptr[stride + 0] + src_ptr[stride + 1] + 
    562         src_ptr[stride + 2] + src_ptr[stride * 2 + 0] + 
    563         src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2]) * 
    564         (65536 / 9) >> 16; 
    565     dst_ptr[1] = (src_ptr[3] + src_ptr[4] + src_ptr[5] + 
    566         src_ptr[stride + 3] + src_ptr[stride + 4] + 
    567         src_ptr[stride + 5] + src_ptr[stride * 2 + 3] + 
    568         src_ptr[stride * 2 + 4] + src_ptr[stride * 2 + 5]) * 
    569         (65536 / 9) >> 16; 
    570     dst_ptr[2] = (src_ptr[6] + src_ptr[7] + 
    571         src_ptr[stride + 6] + src_ptr[stride + 7] + 
    572         src_ptr[stride * 2 + 6] + src_ptr[stride * 2 + 7]) * 
    573         (65536 / 6) >> 16; 
     644    dst_ptr[0] = 
     645        (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[stride + 0] + 
     646         src_ptr[stride + 1] + src_ptr[stride + 2] + src_ptr[stride * 2 + 0] + 
     647         src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2]) * 
     648            (65536 / 9) >> 
     649        16; 
     650    dst_ptr[1] = 
     651        (src_ptr[3] + src_ptr[4] + src_ptr[5] + src_ptr[stride + 3] + 
     652         src_ptr[stride + 4] + src_ptr[stride + 5] + src_ptr[stride * 2 + 3] + 
     653         src_ptr[stride * 2 + 4] + src_ptr[stride * 2 + 5]) * 
     654            (65536 / 9) >> 
     655        16; 
     656    dst_ptr[2] = 
     657        (src_ptr[6] + src_ptr[7] + src_ptr[stride + 6] + src_ptr[stride + 7] + 
     658         src_ptr[stride * 2 + 6] + src_ptr[stride * 2 + 7]) * 
     659            (65536 / 6) >> 
     660        16; 
    574661    src_ptr += 8; 
    575662    dst_ptr += 3; 
    … …  
    579666void ScaleRowDown38_3_Box_16_C(const uint16* src_ptr, 
    580667                               ptrdiff_t src_stride, 
    581                                uint16* dst_ptr, int dst_width) { 
     668                               uint16* dst_ptr, 
     669                               int dst_width) { 
    582670  intptr_t stride = src_stride; 
    583671  int i; 
    584672  assert((dst_width % 3 == 0) && (dst_width > 0)); 
    585673  for (i = 0; i < dst_width; i += 3) { 
    586     dst_ptr[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + 
    587         src_ptr[stride + 0] + src_ptr[stride + 1] + 
    588         src_ptr[stride + 2] + src_ptr[stride * 2 + 0] + 
    589         src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2]) * 
    590         (65536 / 9) >> 16; 
    591     dst_ptr[1] = (src_ptr[3] + src_ptr[4] + src_ptr[5] + 
    592         src_ptr[stride + 3] + src_ptr[stride + 4] + 
    593         src_ptr[stride + 5] + src_ptr[stride * 2 + 3] + 
    594         src_ptr[stride * 2 + 4] + src_ptr[stride * 2 + 5]) * 
    595         (65536 / 9) >> 16; 
    596     dst_ptr[2] = (src_ptr[6] + src_ptr[7] + 
    597         src_ptr[stride + 6] + src_ptr[stride + 7] + 
    598         src_ptr[stride * 2 + 6] + src_ptr[stride * 2 + 7]) * 
    599         (65536 / 6) >> 16; 
     674    dst_ptr[0] = 
     675        (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[stride + 0] + 
     676         src_ptr[stride + 1] + src_ptr[stride + 2] + src_ptr[stride * 2 + 0] + 
     677         src_ptr[stride * 2 + 1] + src_ptr[stride * 2 + 2]) * 
     678            (65536 / 9) >> 
     679        16; 
     680    dst_ptr[1] = 
     681        (src_ptr[3] + src_ptr[4] + src_ptr[5] + src_ptr[stride + 3] + 
     682         src_ptr[stride + 4] + src_ptr[stride + 5] + src_ptr[stride * 2 + 3] + 
     683         src_ptr[stride * 2 + 4] + src_ptr[stride * 2 + 5]) * 
     684            (65536 / 9) >> 
     685        16; 
     686    dst_ptr[2] = 
     687        (src_ptr[6] + src_ptr[7] + src_ptr[stride + 6] + src_ptr[stride + 7] + 
     688         src_ptr[stride * 2 + 6] + src_ptr[stride * 2 + 7]) * 
     689            (65536 / 6) >> 
     690        16; 
    600691    src_ptr += 8; 
    601692    dst_ptr += 3; 
    … …  
    604695 
    605696// 8x2 -> 3x1 
    606 void ScaleRowDown38_2_Box_C(const uint8* src_ptr, ptrdiff_t src_stride, 
    607                             uint8* dst_ptr, int dst_width) { 
     697void ScaleRowDown38_2_Box_C(const uint8* src_ptr, 
     698                            ptrdiff_t src_stride, 
     699                            uint8* dst_ptr, 
     700                            int dst_width) { 
    608701  intptr_t stride = src_stride; 
    609702  int i; 
    610703  assert((dst_width % 3 == 0) && (dst_width > 0)); 
    611704  for (i = 0; i < dst_width; i += 3) { 
    612     dst_ptr[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + 
    613         src_ptr[stride + 0] + src_ptr[stride + 1] + 
    614         src_ptr[stride + 2]) * (65536 / 6) >> 16; 
    615     dst_ptr[1] = (src_ptr[3] + src_ptr[4] + src_ptr[5] + 
    616         src_ptr[stride + 3] + src_ptr[stride + 4] + 
    617         src_ptr[stride + 5]) * (65536 / 6) >> 16; 
    618     dst_ptr[2] = (src_ptr[6] + src_ptr[7] + 
    619         src_ptr[stride + 6] + src_ptr[stride + 7]) * 
    620         (65536 / 4) >> 16; 
     705    dst_ptr[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[stride + 0] + 
     706                  src_ptr[stride + 1] + src_ptr[stride + 2]) * 
     707                     (65536 / 6) >> 
     708                 16; 
     709    dst_ptr[1] = (src_ptr[3] + src_ptr[4] + src_ptr[5] + src_ptr[stride + 3] + 
     710                  src_ptr[stride + 4] + src_ptr[stride + 5]) * 
     711                     (65536 / 6) >> 
     712                 16; 
     713    dst_ptr[2] = 
     714        (src_ptr[6] + src_ptr[7] + src_ptr[stride + 6] + src_ptr[stride + 7]) * 
     715            (65536 / 4) >> 
     716        16; 
    621717    src_ptr += 8; 
    622718    dst_ptr += 3; 
    … …  
    624720} 
    625721 
    626 void ScaleRowDown38_2_Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride, 
    627                                uint16* dst_ptr, int dst_width) { 
     722void ScaleRowDown38_2_Box_16_C(const uint16* src_ptr, 
     723                               ptrdiff_t src_stride, 
     724                               uint16* dst_ptr, 
     725                               int dst_width) { 
    628726  intptr_t stride = src_stride; 
    629727  int i; 
    630728  assert((dst_width % 3 == 0) && (dst_width > 0)); 
    631729  for (i = 0; i < dst_width; i += 3) { 
    632     dst_ptr[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + 
    633         src_ptr[stride + 0] + src_ptr[stride + 1] + 
    634         src_ptr[stride + 2]) * (65536 / 6) >> 16; 
    635     dst_ptr[1] = (src_ptr[3] + src_ptr[4] + src_ptr[5] + 
    636         src_ptr[stride + 3] + src_ptr[stride + 4] + 
    637         src_ptr[stride + 5]) * (65536 / 6) >> 16; 
    638     dst_ptr[2] = (src_ptr[6] + src_ptr[7] + 
    639         src_ptr[stride + 6] + src_ptr[stride + 7]) * 
    640         (65536 / 4) >> 16; 
     730    dst_ptr[0] = (src_ptr[0] + src_ptr[1] + src_ptr[2] + src_ptr[stride + 0] + 
     731                  src_ptr[stride + 1] + src_ptr[stride + 2]) * 
     732                     (65536 / 6) >> 
     733                 16; 
     734    dst_ptr[1] = (src_ptr[3] + src_ptr[4] + src_ptr[5] + src_ptr[stride + 3] + 
     735                  src_ptr[stride + 4] + src_ptr[stride + 5]) * 
     736                     (65536 / 6) >> 
     737                 16; 
     738    dst_ptr[2] = 
     739        (src_ptr[6] + src_ptr[7] + src_ptr[stride + 6] + src_ptr[stride + 7]) * 
     740            (65536 / 4) >> 
     741        16; 
    641742    src_ptr += 8; 
    642743    dst_ptr += 3; 
    … …  
    674775void ScaleARGBRowDown2_C(const uint8* src_argb, 
    675776                         ptrdiff_t src_stride, 
    676                          uint8* dst_argb, int dst_width) { 
     777                         uint8* dst_argb, 
     778                         int dst_width) { 
    677779  const uint32* src = (const uint32*)(src_argb); 
    678780  uint32* dst = (uint32*)(dst_argb); 
    679  
    680   int x; 
     781  int x; 
     782  (void)src_stride; 
    681783  for (x = 0; x < dst_width - 1; x += 2) { 
    682784    dst[0] = src[1]; 
    … …  
    692794void ScaleARGBRowDown2Linear_C(const uint8* src_argb, 
    693795                               ptrdiff_t src_stride, 
    694                                uint8* dst_argb, int dst_width) { 
    695   int x; 
     796                               uint8* dst_argb, 
     797                               int dst_width) { 
     798  int x; 
     799  (void)src_stride; 
    696800  for (x = 0; x < dst_width; ++x) { 
    697801    dst_argb[0] = (src_argb[0] + src_argb[4] + 1) >> 1; 
    … …  
    704808} 
    705809 
    706 void ScaleARGBRowDown2Box_C(const uint8* src_argb, ptrdiff_t src_stride, 
    707                             uint8* dst_argb, int dst_width) { 
     810void ScaleARGBRowDown2Box_C(const uint8* src_argb, 
     811                            ptrdiff_t src_stride, 
     812                            uint8* dst_argb, 
     813                            int dst_width) { 
    708814  int x; 
    709815  for (x = 0; x < dst_width; ++x) { 
    710     dst_argb[0] = (src_argb[0] + src_argb[4] + 
    711                   src_argb[src_stride] + src_argb[src_stride + 4] + 2) >> 2; 
    712     dst_argb[1] = (src_argb[1] + src_argb[5] + 
    713                   src_argb[src_stride + 1] + src_argb[src_stride + 5] + 2) >> 2; 
    714     dst_argb[2] = (src_argb[2] + src_argb[6] + 
    715                   src_argb[src_stride + 2] + src_argb[src_stride + 6] + 2) >> 2; 
    716     dst_argb[3] = (src_argb[3] + src_argb[7] + 
    717                   src_argb[src_stride + 3] + src_argb[src_stride + 7] + 2) >> 2; 
     816    dst_argb[0] = (src_argb[0] + src_argb[4] + src_argb[src_stride] + 
     817                   src_argb[src_stride + 4] + 2) >> 
     818                  2; 
     819    dst_argb[1] = (src_argb[1] + src_argb[5] + src_argb[src_stride + 1] + 
     820                   src_argb[src_stride + 5] + 2) >> 
     821                  2; 
     822    dst_argb[2] = (src_argb[2] + src_argb[6] + src_argb[src_stride + 2] + 
     823                   src_argb[src_stride + 6] + 2) >> 
     824                  2; 
     825    dst_argb[3] = (src_argb[3] + src_argb[7] + src_argb[src_stride + 3] + 
     826                   src_argb[src_stride + 7] + 2) >> 
     827                  2; 
    718828    src_argb += 8; 
    719829    dst_argb += 4; 
    … …  
    721831} 
    722832 
    723 void ScaleARGBRowDownEven_C(const uint8* src_argb, ptrdiff_t src_stride, 
     833void ScaleARGBRowDownEven_C(const uint8* src_argb, 
     834                            ptrdiff_t src_stride, 
    724835                            int src_stepx, 
    725                             uint8* dst_argb, int dst_width) { 
     836                            uint8* dst_argb, 
     837                            int dst_width) { 
    726838  const uint32* src = (const uint32*)(src_argb); 
    727839  uint32* dst = (uint32*)(dst_argb); 
    728  
     840  (void)src_stride; 
    729841  int x; 
    730842  for (x = 0; x < dst_width - 1; x += 2) { 
    … …  
    742854                               ptrdiff_t src_stride, 
    743855                               int src_stepx, 
    744                                uint8* dst_argb, int dst_width) { 
     856                               uint8* dst_argb, 
     857                               int dst_width) { 
    745858  int x; 
    746859  for (x = 0; x < dst_width; ++x) { 
    747     dst_argb[0] = (src_argb[0] + src_argb[4] + 
    748                   src_argb[src_stride] + src_argb[src_stride + 4] + 2) >> 2; 
    749     dst_argb[1] = (src_argb[1] + src_argb[5] + 
    750                   src_argb[src_stride + 1] + src_argb[src_stride + 5] + 2) >> 2; 
    751     dst_argb[2] = (src_argb[2] + src_argb[6] + 
    752                   src_argb[src_stride + 2] + src_argb[src_stride + 6] + 2) >> 2; 
    753     dst_argb[3] = (src_argb[3] + src_argb[7] + 
    754                   src_argb[src_stride + 3] + src_argb[src_stride + 7] + 2) >> 2; 
     860    dst_argb[0] = (src_argb[0] + src_argb[4] + src_argb[src_stride] + 
     861                   src_argb[src_stride + 4] + 2) >> 
     862                  2; 
     863    dst_argb[1] = (src_argb[1] + src_argb[5] + src_argb[src_stride + 1] + 
     864                   src_argb[src_stride + 5] + 2) >> 
     865                  2; 
     866    dst_argb[2] = (src_argb[2] + src_argb[6] + src_argb[src_stride + 2] + 
     867                   src_argb[src_stride + 6] + 2) >> 
     868                  2; 
     869    dst_argb[3] = (src_argb[3] + src_argb[7] + src_argb[src_stride + 3] + 
     870                   src_argb[src_stride + 7] + 2) >> 
     871                  2; 
    755872    src_argb += src_stepx * 4; 
    756873    dst_argb += 4; 
    … …  
    759876 
    760877// Scales a single row of pixels using point sampling. 
    761 void ScaleARGBCols_C(uint8* dst_argb, const uint8* src_argb, 
    762                      int dst_width, int x, int dx) { 
     878void ScaleARGBCols_C(uint8* dst_argb, 
     879                     const uint8* src_argb, 
     880                     int dst_width, 
     881                     int x, 
     882                     int dx) { 
    763883  const uint32* src = (const uint32*)(src_argb); 
    764884  uint32* dst = (uint32*)(dst_argb); 
    … …  
    776896} 
    777897 
    778 void ScaleARGBCols64_C(uint8* dst_argb, const uint8* src_argb, 
    779                        int dst_width, int x32, int dx) { 
     898void ScaleARGBCols64_C(uint8* dst_argb, 
     899                       const uint8* src_argb, 
     900                       int dst_width, 
     901                       int x32, 
     902                       int dx) { 
    780903  int64 x = (int64)(x32); 
    781904  const uint32* src = (const uint32*)(src_argb); 
    … …  
    795918 
    796919// Scales a single row of pixels up by 2x using point sampling. 
    797 void ScaleARGBColsUp2_C(uint8* dst_argb, const uint8* src_argb, 
    798                         int dst_width, int x, int dx) { 
     920void ScaleARGBColsUp2_C(uint8* dst_argb, 
     921                        const uint8* src_argb, 
     922                        int dst_width, 
     923                        int x, 
     924                        int dx) { 
    799925  const uint32* src = (const uint32*)(src_argb); 
    800926  uint32* dst = (uint32*)(dst_argb); 
    801927  int j; 
     928  (void)x; 
     929  (void)dx; 
    802930  for (j = 0; j < dst_width - 1; j += 2) { 
    803931    dst[1] = dst[0] = src[0]; 
    … …  
    810938} 
    811939 
     940// TODO(fbarchard): Replace 0x7f ^ f with 128-f.  bug=607. 
    812941// Mimics SSSE3 blender 
    813 #define BLENDER1(a, b, f) ((a) * (0x7f ^ f) + (b) * f) >> 7 
    814 #define BLENDERC(a, b, f, s) (uint32)( \ 
    815     BLENDER1(((a) >> s) & 255, ((b) >> s) & 255, f) << s) 
    816 #define BLENDER(a, b, f) \ 
    817     BLENDERC(a, b, f, 24) | BLENDERC(a, b, f, 16) | \ 
    818     BLENDERC(a, b, f, 8) | BLENDERC(a, b, f, 0) 
    819  
    820 void ScaleARGBFilterCols_C(uint8* dst_argb, const uint8* src_argb, 
    821                            int dst_width, int x, int dx) { 
     942#define BLENDER1(a, b, f) ((a) * (0x7f ^ f) + (b)*f) >> 7 
     943#define BLENDERC(a, b, f, s) \ 
     944  (uint32)(BLENDER1(((a) >> s) & 255, ((b) >> s) & 255, f) << s) 
     945#define BLENDER(a, b, f)                                                 \ 
     946  BLENDERC(a, b, f, 24) | BLENDERC(a, b, f, 16) | BLENDERC(a, b, f, 8) | \ 
     947      BLENDERC(a, b, f, 0) 
     948 
     949void ScaleARGBFilterCols_C(uint8* dst_argb, 
     950                           const uint8* src_argb, 
     951                           int dst_width, 
     952                           int x, 
     953                           int dx) { 
    822954  const uint32* src = (const uint32*)(src_argb); 
    823955  uint32* dst = (uint32*)(dst_argb); 
    … …  
    847979} 
    848980 
    849 void ScaleARGBFilterCols64_C(uint8* dst_argb, const uint8* src_argb, 
    850                              int dst_width, int x32, int dx) { 
     981void ScaleARGBFilterCols64_C(uint8* dst_argb, 
     982                             const uint8* src_argb, 
     983                             int dst_width, 
     984                             int x32, 
     985                             int dx) { 
    851986  int64 x = (int64)(x32); 
    852987  const uint32* src = (const uint32*)(src_argb); 
    … …  
    8821017// Scale plane vertically with bilinear interpolation. 
    8831018void ScalePlaneVertical(int src_height, 
    884                         int dst_width, int dst_height, 
    885                         int src_stride, int dst_stride, 
    886                         const uint8* src_argb, uint8* dst_argb, 
    887                         int x, int y, int dy, 
    888                         int bpp, enum FilterMode filtering) { 
     1019                        int dst_width, 
     1020                        int dst_height, 
     1021                        int src_stride, 
     1022                        int dst_stride, 
     1023                        const uint8* src_argb, 
     1024                        uint8* dst_argb, 
     1025                        int x, 
     1026                        int y, 
     1027                        int dy, 
     1028                        int bpp, 
     1029                        enum FilterMode filtering) { 
    8891030  // TODO(fbarchard): Allow higher bpp. 
    8901031  int dst_width_bytes = dst_width * bpp; 
    891   void (*InterpolateRow)(uint8* dst_argb, const uint8* src_argb, 
    892       ptrdiff_t src_stride, int dst_width, int source_y_fraction) = 
    893       InterpolateRow_C; 
     1032  void (*InterpolateRow)(uint8 * dst_argb, const uint8* src_argb, 
     1033                         ptrdiff_t src_stride, int dst_width, 
     1034                         int source_y_fraction) = InterpolateRow_C; 
    8941035  const int max_y = (src_height > 1) ? ((src_height - 1) << 16) - 1 : 0; 
    8951036  int j; 
    … …  
    9241065#endif 
    9251066#if defined(HAS_INTERPOLATEROW_DSPR2) 
    926   if (TestCpuFlag(kCpuHasDSPR2) && 
    927       IS_ALIGNED(src_argb, 4) && IS_ALIGNED(src_stride, 4) && 
    928       IS_ALIGNED(dst_argb, 4) && IS_ALIGNED(dst_stride, 4)) { 
     1067  if (TestCpuFlag(kCpuHasDSPR2) && IS_ALIGNED(src_argb, 4) && 
     1068      IS_ALIGNED(src_stride, 4) && IS_ALIGNED(dst_argb, 4) && 
     1069      IS_ALIGNED(dst_stride, 4)) { 
    9291070    InterpolateRow = InterpolateRow_Any_DSPR2; 
    9301071    if (IS_ALIGNED(dst_width_bytes, 4)) { 
    9311072      InterpolateRow = InterpolateRow_DSPR2; 
     1073    } 
     1074  } 
     1075#endif 
     1076#if defined(HAS_INTERPOLATEROW_MSA) 
     1077  if (TestCpuFlag(kCpuHasMSA)) { 
     1078    InterpolateRow = InterpolateRow_Any_MSA; 
     1079    if (IS_ALIGNED(dst_width_bytes, 32)) { 
     1080      InterpolateRow = InterpolateRow_MSA; 
    9321081    } 
    9331082  } 
    … …  
    9411090    yi = y >> 16; 
    9421091    yf = filtering ? ((y >> 8) & 255) : 0; 
    943     InterpolateRow(dst_argb, src_argb + yi * src_stride, 
    944                    src_stride, dst_width_bytes, yf); 
     1092    InterpolateRow(dst_argb, src_argb + yi * src_stride, src_stride, 
     1093                   dst_width_bytes, yf); 
    9451094    dst_argb += dst_stride; 
    9461095    y += dy; 
    … …  
    9481097} 
    9491098void ScalePlaneVertical_16(int src_height, 
    950                            int dst_width, int dst_height, 
    951                            int src_stride, int dst_stride, 
    952                            const uint16* src_argb, uint16* dst_argb, 
    953                            int x, int y, int dy, 
    954                            int wpp, enum FilterMode filtering) { 
     1099                           int dst_width, 
     1100                           int dst_height, 
     1101                           int src_stride, 
     1102                           int dst_stride, 
     1103                           const uint16* src_argb, 
     1104                           uint16* dst_argb, 
     1105                           int x, 
     1106                           int y, 
     1107                           int dy, 
     1108                           int wpp, 
     1109                           enum FilterMode filtering) { 
    9551110  // TODO(fbarchard): Allow higher wpp. 
    9561111  int dst_width_words = dst_width * wpp; 
    957   void (*InterpolateRow)(uint16* dst_argb, const uint16* src_argb, 
    958       ptrdiff_t src_stride, int dst_width, int source_y_fraction) = 
    959       InterpolateRow_16_C; 
     1112  void (*InterpolateRow)(uint16 * dst_argb, const uint16* src_argb, 
     1113                         ptrdiff_t src_stride, int dst_width, 
     1114                         int source_y_fraction) = InterpolateRow_16_C; 
    9601115  const int max_y = (src_height > 1) ? ((src_height - 1) << 16) - 1 : 0; 
    9611116  int j; 
    … …  
    9981153#endif 
    9991154#if defined(HAS_INTERPOLATEROW_16_DSPR2) 
    1000   if (TestCpuFlag(kCpuHasDSPR2) && 
    1001       IS_ALIGNED(src_argb, 4) && IS_ALIGNED(src_stride, 4) && 
    1002       IS_ALIGNED(dst_argb, 4) && IS_ALIGNED(dst_stride, 4)) { 
     1155  if (TestCpuFlag(kCpuHasDSPR2) && IS_ALIGNED(src_argb, 4) && 
     1156      IS_ALIGNED(src_stride, 4) && IS_ALIGNED(dst_argb, 4) && 
     1157      IS_ALIGNED(dst_stride, 4)) { 
    10031158    InterpolateRow = InterpolateRow_Any_16_DSPR2; 
    10041159    if (IS_ALIGNED(dst_width_bytes, 4)) { 
    … …  
    10151170    yi = y >> 16; 
    10161171    yf = filtering ? ((y >> 8) & 255) : 0; 
    1017     InterpolateRow(dst_argb, src_argb + yi * src_stride, 
    1018                    src_stride, dst_width_words, yf); 
     1172    InterpolateRow(dst_argb, src_argb + yi * src_stride, src_stride, 
     1173                   dst_width_words, yf); 
    10191174    dst_argb += dst_stride; 
    10201175    y += dy; 
    … …  
    10231178 
    10241179// Simplify the filtering based on scale factors. 
    1025 enum FilterMode ScaleFilterReduce(int src_width, int src_height, 
    1026                                   int dst_width, int dst_height, 
     1180enum FilterMode ScaleFilterReduce(int src_width, 
     1181                                  int src_height, 
     1182                                  int dst_width, 
     1183                                  int dst_height, 
    10271184                                  enum FilterMode filtering) { 
    10281185  if (src_width < 0) { 
    … …  
    10711228// Divide num by div and return as 16.16 fixed point result. 
    10721229int FixedDiv1_C(int num, int div) { 
    1073   return (int)((((int64)(num) << 16) - 0x00010001) / 
    1074                           (div - 1)); 
     1230  return (int)((((int64)(num) << 16) - 0x00010001) / (div - 1)); 
    10751231} 
    10761232 
    … …  
    10781234 
    10791235// Compute slope values for stepping. 
    1080 void ScaleSlope(int src_width, int src_height, 
    1081                 int dst_width, int dst_height, 
     1236void ScaleSlope(int src_width, 
     1237                int src_height, 
     1238                int dst_width, 
     1239                int dst_height, 
    10821240                enum FilterMode filtering, 
    1083                 int* x, int* y, int* dx, int* dy) { 
     1241                int* x, 
     1242                int* y, 
     1243                int* dx, 
     1244                int* dy) { 
    10841245  assert(x != NULL); 
    10851246  assert(y != NULL); 
    … …  
    11131274    } 
    11141275    if (dst_height <= src_height) { 
    1115       *dy = FixedDiv(src_height,  dst_height); 
     1276      *dy = FixedDiv(src_height, dst_height); 
    11161277      *y = CENTERSTART(*dy, -32768);  // Subtract 0.5 (32768) to center filter. 
    11171278    } else if (dst_height > 1) { 
Note: See TracChangeset for help on using the changeset viewer.