Merge to XFA: Use stdint.h types throughout PDFium.

core/src/fxge/dib/fx_dib_transform.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
  
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../../include/fxge/fx_dib.h"
 #include "dib_int.h"
 int SDP_Table[513] = {
     256, 256, 256, 256, 256, 256, 256, 256, 256, 255, 255, 255, 255, 255, 255, 254, 254, 254, 254,
@@ skipping 241 matching lines @@
                         pDestMatrix->c / stretch_height, pDestMatrix->d / stretch_height, pDestMatrix->e, pDestMatrix->f);
     m_dest2stretch.SetReverse(stretch2dest);
     CFX_FloatRect clip_rect_f(result_clip);
     clip_rect_f.Transform(&m_dest2stretch);
     m_StretchClip = clip_rect_f.GetOutterRect();
     m_StretchClip.Intersect(0, 0, stretch_width, stretch_height);
     m_Stretcher.Start(&m_Storer, pSrc, stretch_width, stretch_height, m_StretchClip, flags);
     m_Status = 3;
     return TRUE;
 }
-FX_BYTE _bilinear_interpol(FX_LPCBYTE buf, int row_offset_l, int row_offset_r,
+uint8_t _bilinear_interpol(FX_LPCBYTE buf, int row_offset_l, int row_offset_r,
                            int src_col_l, int src_col_r, int res_x, int res_y,
                            int bpp, int c_offset)
 {
     int i_resx = 255 - res_x;
     int col_bpp_l = src_col_l * bpp;
     int col_bpp_r = src_col_r * bpp;
     FX_LPCBYTE buf_u = buf + row_offset_l + c_offset;
     FX_LPCBYTE buf_d = buf + row_offset_r + c_offset;
     FX_LPCBYTE src_pos0 = buf_u + col_bpp_l;
     FX_LPCBYTE src_pos1 = buf_u + col_bpp_r;
     FX_LPCBYTE src_pos2 = buf_d + col_bpp_l;
     FX_LPCBYTE src_pos3 = buf_d + col_bpp_r;
-    FX_BYTE r_pos_0 = (*src_pos0 * i_resx + *src_pos1 * res_x) >> 8;
-    FX_BYTE r_pos_1 = (*src_pos2 * i_resx + *src_pos3 * res_x) >> 8;
+    uint8_t r_pos_0 = (*src_pos0 * i_resx + *src_pos1 * res_x) >> 8;
+    uint8_t r_pos_1 = (*src_pos2 * i_resx + *src_pos3 * res_x) >> 8;
     return (r_pos_0 * (255 - res_y) + r_pos_1 * res_y) >> 8;
 }
-FX_BYTE _bicubic_interpol(FX_LPCBYTE buf, int pitch, int pos_pixel[], int u_w[], int v_w[], int res_x, int res_y,
+uint8_t _bicubic_interpol(FX_LPCBYTE buf, int pitch, int pos_pixel[], int u_w[], int v_w[], int res_x, int res_y,
                           int bpp, int c_offset)
 {
     int s_result = 0;
     for (int i = 0; i < 4; i ++) {
         int a_result = 0;
         for (int j = 0; j < 4; j ++) {
-            a_result += u_w[j] * (*(FX_BYTE*)(buf + pos_pixel[i + 4] * pitch + pos_pixel[j] * bpp + c_offset));
+            a_result += u_w[j] * (*(uint8_t*)(buf + pos_pixel[i + 4] * pitch + pos_pixel[j] * bpp + c_offset));
         }
         s_result += a_result * v_w[i];
     }
     s_result >>= 16;
-    return (FX_BYTE)(s_result < 0 ? 0 : s_result > 255 ? 255 : s_result);
+    return (uint8_t)(s_result < 0 ? 0 : s_result > 255 ? 255 : s_result);
 }
 void _bicubic_get_pos_weight(int pos_pixel[], int u_w[], int v_w[], int src_col_l, int src_row_l,
                              int res_x, int res_y, int stretch_width, int stretch_height)
 {
     pos_pixel[0] = src_col_l - 1;
     pos_pixel[1] = src_col_l;
     pos_pixel[2] = src_col_l + 1;
     pos_pixel[3] = src_col_l + 2;
     pos_pixel[4] = src_row_l - 1;
     pos_pixel[5] = src_row_l;
@@ skipping 81 matching lines @@
     CFX_AffineMatrix result2stretch(1.0f, 0.0f, 0.0f, 1.0f, (FX_FLOAT)(m_ResultLeft), (FX_FLOAT)(m_ResultTop));
     result2stretch.Concat(m_dest2stretch);
     result2stretch.TranslateI(-m_StretchClip.left, -m_StretchClip.top);
     if (stretch_buf_mask == NULL && pTransformed->m_pAlphaMask) {
         pTransformed->m_pAlphaMask->Clear(0xff000000);
     } else if (pTransformed->m_pAlphaMask) {
         int stretch_pitch_mask = m_Storer.GetBitmap()->m_pAlphaMask->GetPitch();
         if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
             CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
             for (int row = 0; row < m_ResultHeight; row ++) {
-                FX_BYTE* dest_pos_mask = (FX_BYTE*)pTransformed->m_pAlphaMask->GetScanline(row);
+                uint8_t* dest_pos_mask = (uint8_t*)pTransformed->m_pAlphaMask->GetScanline(row);
                 for (int col = 0; col < m_ResultWidth; col ++) {
                     int src_col_l, src_row_l, res_x, res_y;
                     result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);
                     if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {
                         if (src_col_l == stretch_width) {
                             src_col_l--;
                         }
                         if (src_row_l == stretch_height) {
                             src_row_l--;
                         }
                         int src_col_r = src_col_l + 1;
                         int src_row_r = src_row_l + 1;
                         if (src_col_r == stretch_width) {
                             src_col_r--;
                         }
                         if (src_row_r == stretch_height) {
                             src_row_r--;
                         }
                         int row_offset_l = src_row_l * stretch_pitch_mask;
                         int row_offset_r = src_row_r * stretch_pitch_mask;
                         *dest_pos_mask = _bilinear_interpol(stretch_buf_mask, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, 1, 0);
                     }
                     dest_pos_mask++;
                 }
             }
         } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
             CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
             for (int row = 0; row < m_ResultHeight; row ++) {
-                FX_BYTE* dest_pos_mask = (FX_BYTE*)pTransformed->m_pAlphaMask->GetScanline(row);
+                uint8_t* dest_pos_mask = (uint8_t*)pTransformed->m_pAlphaMask->GetScanline(row);
                 for (int col = 0; col < m_ResultWidth; col ++) {
                     int src_col_l, src_row_l, res_x, res_y;
                     result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);
                     if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {
                         int pos_pixel[8];
                         int u_w[4], v_w[4];
                         if (src_col_l == stretch_width) {
                             src_col_l--;
                         }
                         if (src_row_l == stretch_height) {
                             src_row_l--;
                         }
                         _bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l, res_x, res_y, stretch_width, stretch_height);
                         *dest_pos_mask = _bicubic_interpol(stretch_buf_mask, stretch_pitch_mask, pos_pixel, u_w, v_w, res_x, res_y, 1, 0);
                     }
                     dest_pos_mask++;
                 }
             }
         } else {
             CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);
             for (int row = 0; row < m_ResultHeight; row ++) {
-                FX_BYTE* dest_pos_mask = (FX_BYTE*)pTransformed->m_pAlphaMask->GetScanline(row);
+                uint8_t* dest_pos_mask = (uint8_t*)pTransformed->m_pAlphaMask->GetScanline(row);
                 for (int col = 0; col < m_ResultWidth; col ++) {
                     int src_col, src_row;
                     result2stretch_fix.Transform(col, row, src_col, src_row);
                     if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 && src_row <= stretch_height) {
                         if (src_col == stretch_width) {
                             src_col --;
                         }
                         if (src_row == stretch_height) {
                             src_row --;
                         }
@@ skipping 93 matching lines @@
                         argb[i] = 255 - i;
                     }
                 else
                     for (int i = 0; i < 256; i ++) {
                         argb[i] = 0xff000000 | (i * 0x010101);
                     }
             }
             if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
                 for (int row = 0; row < m_ResultHeight; row ++) {
-                    FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);
+                    uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
                     for (int col = 0; col < m_ResultWidth; col ++) {
                         int src_col_l, src_row_l, res_x, res_y;
                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);
                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {
                             if (src_col_l == stretch_width) {
                                 src_col_l--;
                             }
                             if (src_row_l == stretch_height) {
                                 src_row_l--;
                             }
                             int src_col_r = src_col_l + 1;
                             int src_row_r = src_row_l + 1;
                             if (src_col_r == stretch_width) {
                                 src_col_r--;
                             }
                             if (src_row_r == stretch_height) {
                                 src_row_r--;
                             }
                             int row_offset_l = src_row_l * stretch_pitch;
                             int row_offset_r = src_row_r * stretch_pitch;
                             FX_DWORD r_bgra_cmyk = argb[_bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, 1, 0)];
                             if (transformF == FXDIB_Rgba) {
-                                dest_pos[0] = (FX_BYTE)(r_bgra_cmyk >> 24);
-                                dest_pos[1] = (FX_BYTE)(r_bgra_cmyk >> 16);
-                                dest_pos[2] = (FX_BYTE)(r_bgra_cmyk >> 8);
+                                dest_pos[0] = (uint8_t)(r_bgra_cmyk >> 24);
+                                dest_pos[1] = (uint8_t)(r_bgra_cmyk >> 16);
+                                dest_pos[2] = (uint8_t)(r_bgra_cmyk >> 8);
                             } else {
                                 *(FX_DWORD*)dest_pos = r_bgra_cmyk;
                             }
                         }
                         dest_pos += destBpp;
                     }
                 }
             } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
                 for (int row = 0; row < m_ResultHeight; row ++) {
-                    FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);
+                    uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
                     for (int col = 0; col < m_ResultWidth; col ++) {
                         int src_col_l, src_row_l, res_x, res_y;
                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);
                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {
                             int pos_pixel[8];
                             int u_w[4], v_w[4];
                             if (src_col_l == stretch_width) {
                                 src_col_l--;
                             }
                             if (src_row_l == stretch_height) {
                                 src_row_l--;
                             }
                             _bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l, res_x, res_y, stretch_width, stretch_height);
                             FX_DWORD r_bgra_cmyk = argb[_bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, 1, 0)];
                             if (transformF == FXDIB_Rgba) {
-                                dest_pos[0] = (FX_BYTE)(r_bgra_cmyk >> 24);
-                                dest_pos[1] = (FX_BYTE)(r_bgra_cmyk >> 16);
-                                dest_pos[2] = (FX_BYTE)(r_bgra_cmyk >> 8);
+                                dest_pos[0] = (uint8_t)(r_bgra_cmyk >> 24);
+                                dest_pos[1] = (uint8_t)(r_bgra_cmyk >> 16);
+                                dest_pos[2] = (uint8_t)(r_bgra_cmyk >> 8);
                             } else {
                                 *(FX_DWORD*)dest_pos = r_bgra_cmyk;
                             }
                         }
                         dest_pos += destBpp;
                     }
                 }
             } else {
                 CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);
                 for (int row = 0; row < m_ResultHeight; row ++) {
-                    FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);
+                    uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
                     for (int col = 0; col < m_ResultWidth; col ++) {
                         int src_col, src_row;
                         result2stretch_fix.Transform(col, row, src_col, src_row);
                         if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 && src_row <= stretch_height) {
                             if (src_col == stretch_width) {
                                 src_col --;
                             }
                             if (src_row == stretch_height) {
                                 src_row --;
                             }
                             FX_DWORD r_bgra_cmyk = argb[stretch_buf[src_row * stretch_pitch + src_col]];
                             if (transformF == FXDIB_Rgba) {
-                                dest_pos[0] = (FX_BYTE)(r_bgra_cmyk >> 24);
-                                dest_pos[1] = (FX_BYTE)(r_bgra_cmyk >> 16);
-                                dest_pos[2] = (FX_BYTE)(r_bgra_cmyk >> 8);
+                                dest_pos[0] = (uint8_t)(r_bgra_cmyk >> 24);
+                                dest_pos[1] = (uint8_t)(r_bgra_cmyk >> 16);
+                                dest_pos[2] = (uint8_t)(r_bgra_cmyk >> 8);
                             } else {
                                 *(FX_DWORD*)dest_pos = r_bgra_cmyk;
                             }
                         }
                         dest_pos += destBpp;
                     }
                 }
             }
         } else {
             FX_BOOL bHasAlpha = m_Storer.GetBitmap()->HasAlpha();
             int destBpp = pTransformed->GetBPP() / 8;
             if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
                 for (int row = 0; row < m_ResultHeight; row ++) {
-                    FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);
+                    uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
                     for (int col = 0; col < m_ResultWidth; col ++) {
                         int src_col_l, src_row_l, res_x, res_y, r_pos_k_r = 0;
                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);
                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {
                             if (src_col_l == stretch_width) {
                                 src_col_l--;
                             }
                             if (src_row_l == stretch_height) {
                                 src_row_l--;
                             }
                             int src_col_r = src_col_l + 1;
                             int src_row_r = src_row_l + 1;
                             if (src_col_r == stretch_width) {
                                 src_col_r--;
                             }
                             if (src_row_r == stretch_height) {
                                 src_row_r--;
                             }
                             int row_offset_l = src_row_l * stretch_pitch;
                             int row_offset_r = src_row_r * stretch_pitch;
-                            FX_BYTE r_pos_red_y_r   = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 2);
-                            FX_BYTE r_pos_green_m_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 1);
-                            FX_BYTE r_pos_blue_c_r  = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 0);
+                            uint8_t r_pos_red_y_r   = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 2);
+                            uint8_t r_pos_green_m_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 1);
+                            uint8_t r_pos_blue_c_r  = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 0);
                             if (bHasAlpha) {
                                 if (transformF != FXDIB_Argb) {
                                     if (transformF == FXDIB_Rgba) {
                                         dest_pos[0] = r_pos_blue_c_r;
                                         dest_pos[1] = r_pos_green_m_r;
                                         dest_pos[2] = r_pos_red_y_r;
                                     } else {
                                         r_pos_k_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 3);
                                         *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(r_pos_blue_c_r, r_pos_green_m_r, r_pos_red_y_r, r_pos_k_r));
                                     }
                                 } else {
-                                    FX_BYTE r_pos_a_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 3);
+                                    uint8_t r_pos_a_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 3);
                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(r_pos_a_r, r_pos_red_y_r, r_pos_green_m_r, r_pos_blue_c_r));
                                 }
                             } else {
                                 r_pos_k_r = 0xff;
                                 if (transformF == FXDIB_Cmyka) {
                                     r_pos_k_r = _bilinear_interpol(stretch_buf, row_offset_l, row_offset_r, src_col_l, src_col_r, res_x, res_y, Bpp, 3);
                                     *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(r_pos_blue_c_r, r_pos_green_m_r, r_pos_red_y_r, r_pos_k_r));
                                 } else {
                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(r_pos_k_r, r_pos_red_y_r, r_pos_green_m_r, r_pos_blue_c_r));
                                 }
                             }
                         }
                         dest_pos += destBpp;
                     }
                 }
             } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
                 for (int row = 0; row < m_ResultHeight; row ++) {
-                    FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);
+                    uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
                     for (int col = 0; col < m_ResultWidth; col ++) {
                         int src_col_l, src_row_l, res_x, res_y, r_pos_k_r = 0;
                         result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x, res_y);
                         if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 && src_row_l <= stretch_height) {
                             int pos_pixel[8];
                             int u_w[4], v_w[4];
                             if (src_col_l == stretch_width) {
                                 src_col_l--;
                             }
                             if (src_row_l == stretch_height) {
                                 src_row_l--;
                             }
                             _bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l, res_x, res_y, stretch_width, stretch_height);
-                            FX_BYTE r_pos_red_y_r   = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 2);
-                            FX_BYTE r_pos_green_m_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 1);
-                            FX_BYTE r_pos_blue_c_r  = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 0);
+                            uint8_t r_pos_red_y_r   = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 2);
+                            uint8_t r_pos_green_m_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 1);
+                            uint8_t r_pos_blue_c_r  = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 0);
                             if (bHasAlpha) {
                                 if (transformF != FXDIB_Argb) {
                                     if (transformF == FXDIB_Rgba) {
                                         dest_pos[0] = r_pos_blue_c_r;
                                         dest_pos[1] = r_pos_green_m_r;
                                         dest_pos[2] = r_pos_red_y_r;
                                     } else {
                                         r_pos_k_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 3);
                                         *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(r_pos_blue_c_r, r_pos_green_m_r, r_pos_red_y_r, r_pos_k_r));
                                     }
                                 } else {
-                                    FX_BYTE r_pos_a_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 3);
+                                    uint8_t r_pos_a_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 3);
                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(r_pos_a_r, r_pos_red_y_r, r_pos_green_m_r, r_pos_blue_c_r));
                                 }
                             } else {
                                 r_pos_k_r = 0xff;
                                 if (transformF == FXDIB_Cmyka) {
                                     r_pos_k_r = _bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel, u_w, v_w, res_x, res_y, Bpp, 3);
                                     *(FX_DWORD*)dest_pos = FXCMYK_TODIB(CmykEncode(r_pos_blue_c_r, r_pos_green_m_r, r_pos_red_y_r, r_pos_k_r));
                                 } else {
                                     *(FX_DWORD*)dest_pos = FXARGB_TODIB(FXARGB_MAKE(r_pos_k_r, r_pos_red_y_r, r_pos_green_m_r, r_pos_blue_c_r));
                                 }
                             }
                         }
                         dest_pos += destBpp;
                     }
                 }
             } else {
                 CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);
                 for (int row = 0; row < m_ResultHeight; row ++) {
-                    FX_BYTE* dest_pos = (FX_BYTE*)pTransformed->GetScanline(row);
+                    uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
                     for (int col = 0; col < m_ResultWidth; col ++) {
                         int src_col, src_row;
                         result2stretch_fix.Transform(col, row, src_col, src_row);
                         if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 && src_row <= stretch_height) {
                             if (src_col == stretch_width) {
                                 src_col --;
                             }
                             if (src_row == stretch_height) {
                                 src_row --;
                             }
@@ skipping 20 matching lines @@
                         }
                         dest_pos += destBpp;
                     }
                 }
             }
         }
     }
     m_Storer.Replace(pTransformed);
     return FALSE;
 }