Remove CFX_AffineMatrix/CPDF_Matrix

core/src/fpdfapi/fpdf_render/fpdf_render_pattern.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 "render_int.h"
 
 #include "core/include/fpdfapi/fpdf_pageobj.h"
 #include "core/include/fpdfapi/fpdf_render.h"
 #include "core/include/fxge/fx_ge.h"
 #include "core/src/fpdfapi/fpdf_page/pageint.h"
 
 #define SHADING_STEPS 256
 static void DrawAxialShading(CFX_DIBitmap* pBitmap,
-                             CFX_AffineMatrix* pObject2Bitmap,
+                             CFX_Matrix* pObject2Bitmap,
                              CPDF_Dictionary* pDict,
                              CPDF_Function** pFuncs,
                              int nFuncs,
                              CPDF_ColorSpace* pCS,
                              int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
   CPDF_Array* pCoords = pDict->GetArray(FX_BSTRC("Coords"));
   if (pCoords == NULL) {
     return;
   }
@@ skipping 12 matching lines @@
   if (pArray) {
     bStartExtend = pArray->GetInteger(0);
     bEndExtend = pArray->GetInteger(1);
   }
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   FX_FLOAT x_span = end_x - start_x;
   FX_FLOAT y_span = end_y - start_y;
   FX_FLOAT axis_len_square =
       FXSYS_Mul(x_span, x_span) + FXSYS_Mul(y_span, y_span);
-  CFX_AffineMatrix matrix;
+  CFX_Matrix matrix;
   matrix.SetReverse(*pObject2Bitmap);
   int total_results = 0;
   for (int j = 0; j < nFuncs; j++) {
     if (pFuncs[j]) {
       total_results += pFuncs[j]->CountOutputs();
     }
   }
   if (pCS->CountComponents() > total_results) {
     total_results = pCS->CountComponents();
   }
@@ skipping 37 matching lines @@
         if (!bEndExtend) {
           continue;
         }
         index = SHADING_STEPS - 1;
       }
       dib_buf[column] = rgb_array[index];
     }
   }
 }
 static void DrawRadialShading(CFX_DIBitmap* pBitmap,
-                              CFX_AffineMatrix* pObject2Bitmap,
+                              CFX_Matrix* pObject2Bitmap,
                               CPDF_Dictionary* pDict,
                               CPDF_Function** pFuncs,
                               int nFuncs,
                               CPDF_ColorSpace* pCS,
                               int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
   CPDF_Array* pCoords = pDict->GetArray(FX_BSTRC("Coords"));
   if (pCoords == NULL) {
     return;
   }
   FX_FLOAT start_x = pCoords->GetNumber(0);
   FX_FLOAT start_y = pCoords->GetNumber(1);
   FX_FLOAT start_r = pCoords->GetNumber(2);
   FX_FLOAT end_x = pCoords->GetNumber(3);
   FX_FLOAT end_y = pCoords->GetNumber(4);
   FX_FLOAT end_r = pCoords->GetNumber(5);
-  CFX_AffineMatrix matrix;
+  CFX_Matrix matrix;
   matrix.SetReverse(*pObject2Bitmap);
   FX_FLOAT t_min = 0, t_max = 1.0f;
   CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Domain"));
   if (pArray) {
     t_min = pArray->GetNumber(0);
     t_max = pArray->GetNumber(1);
   }
   FX_BOOL bStartExtend = FALSE, bEndExtend = FALSE;
   pArray = pDict->GetArray(FX_BSTRC("Extend"));
   if (pArray) {
@@ skipping 100 matching lines @@
         if (!bEndExtend) {
           continue;
         }
         index = SHADING_STEPS - 1;
       }
       dib_buf[column] = rgb_array[index];
     }
   }
 }
 static void DrawFuncShading(CFX_DIBitmap* pBitmap,
-                            CFX_AffineMatrix* pObject2Bitmap,
+                            CFX_Matrix* pObject2Bitmap,
                             CPDF_Dictionary* pDict,
                             CPDF_Function** pFuncs,
                             int nFuncs,
                             CPDF_ColorSpace* pCS,
                             int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
   CPDF_Array* pDomain = pDict->GetArray(FX_BSTRC("Domain"));
   FX_FLOAT xmin = 0, ymin = 0, xmax = 1.0f, ymax = 1.0f;
   if (pDomain) {
     xmin = pDomain->GetNumber(0);
     xmax = pDomain->GetNumber(1);
     ymin = pDomain->GetNumber(2);
     ymax = pDomain->GetNumber(3);
   }
-  CFX_AffineMatrix mtDomain2Target = pDict->GetMatrix(FX_BSTRC("Matrix"));
-  CFX_AffineMatrix matrix, reverse_matrix;
+  CFX_Matrix mtDomain2Target = pDict->GetMatrix(FX_BSTRC("Matrix"));
+  CFX_Matrix matrix, reverse_matrix;
   matrix.SetReverse(*pObject2Bitmap);
   reverse_matrix.SetReverse(mtDomain2Target);
   matrix.Concat(reverse_matrix);
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   int pitch = pBitmap->GetPitch();
   int total_results = 0;
   for (int j = 0; j < nFuncs; j++) {
     if (pFuncs[j]) {
       total_results += pFuncs[j]->CountOutputs();
@@ skipping 132 matching lines @@
       G += g_unit;
       B += b_unit;
       FXARGB_SETDIB(dib_buf,
                     FXARGB_MAKE(alpha, (int32_t)(R * 255), (int32_t)(G * 255),
                                 (int32_t)(B * 255)));
       dib_buf += 4;
     }
   }
 }
 static void DrawFreeGouraudShading(CFX_DIBitmap* pBitmap,
-                                   CFX_AffineMatrix* pObject2Bitmap,
+                                   CFX_Matrix* pObject2Bitmap,
                                    CPDF_Stream* pShadingStream,
                                    CPDF_Function** pFuncs,
                                    int nFuncs,
                                    CPDF_ColorSpace* pCS,
                                    int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
 
   CPDF_MeshStream stream;
   if (!stream.Load(pShadingStream, pFuncs, nFuncs, pCS))
     return;
@@ skipping 13 matching lines @@
       if (flag == 1) {
         triangle[0] = triangle[1];
       }
       triangle[1] = triangle[2];
       triangle[2] = vertex;
     }
     DrawGouraud(pBitmap, alpha, triangle);
   }
 }
 static void DrawLatticeGouraudShading(CFX_DIBitmap* pBitmap,
-                                      CFX_AffineMatrix* pObject2Bitmap,
+                                      CFX_Matrix* pObject2Bitmap,
                                       CPDF_Stream* pShadingStream,
                                       CPDF_Function** pFuncs,
                                       int nFuncs,
                                       CPDF_ColorSpace* pCS,
                                       int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
 
   int row_verts = pShadingStream->GetDict()->GetInteger("VerticesPerRow");
   if (row_verts < 2)
     return;
@@ skipping 282 matching lines @@
                        stream.m_nCompBits == 12 || stream.m_nCompBits == 16);
 
   FX_BOOL bFlagBits = (stream.m_nFlagBits == 2 || stream.m_nFlagBits == 4 ||
                        stream.m_nFlagBits == 8);
 
   return bCoorBits && bCompBits && bFlagBits;
 }
 
 static void DrawCoonPatchMeshes(FX_BOOL bTensor,
                                 CFX_DIBitmap* pBitmap,
-                                CFX_AffineMatrix* pObject2Bitmap,
+                                CFX_Matrix* pObject2Bitmap,
                                 CPDF_Stream* pShadingStream,
                                 CPDF_Function** pFuncs,
                                 int nFuncs,
                                 CPDF_ColorSpace* pCS,
                                 int fill_mode,
                                 int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
 
   CFX_FxgeDevice device;
   device.Attach(pBitmap);
@@ skipping 57 matching lines @@
     C2.FromPoints(coords[3].x, coords[3].y, coords[4].x, coords[4].y,
                   coords[5].x, coords[5].y, coords[6].x, coords[6].y);
     D1.FromPoints(coords[0].x, coords[0].y, coords[1].x, coords[1].y,
                   coords[2].x, coords[2].y, coords[3].x, coords[3].y);
     D2.FromPoints(coords[9].x, coords[9].y, coords[8].x, coords[8].y,
                   coords[7].x, coords[7].y, coords[6].x, coords[6].y);
     patch.Draw(1, 1, 0, 0, C1, C2, D1, D2);
   }
 }
 void CPDF_RenderStatus::DrawShading(CPDF_ShadingPattern* pPattern,
-                                    CFX_AffineMatrix* pMatrix,
+                                    CFX_Matrix* pMatrix,
                                     FX_RECT& clip_rect,
                                     int alpha,
                                     FX_BOOL bAlphaMode) {
   CPDF_Function** pFuncs = pPattern->m_pFunctions;
   int nFuncs = pPattern->m_nFuncs;
   CPDF_Dictionary* pDict = pPattern->m_pShadingObj->GetDict();
   CPDF_ColorSpace* pColorSpace = pPattern->m_pCS;
   if (pColorSpace == NULL) {
     return;
   }
@@ skipping 14 matching lines @@
                               (int32_t)(B * 255));
     }
   }
   if (pDict->KeyExist(FX_BSTRC("BBox"))) {
     CFX_FloatRect rect = pDict->GetRect(FX_BSTRC("BBox"));
     rect.Transform(pMatrix);
     clip_rect.Intersect(rect.GetOutterRect());
   }
   CPDF_DeviceBuffer buffer;
   buffer.Initialize(m_pContext, m_pDevice, &clip_rect, m_pCurObj, 150);
-  CFX_AffineMatrix FinalMatrix = *pMatrix;
+  CFX_Matrix FinalMatrix = *pMatrix;
   FinalMatrix.Concat(*buffer.GetMatrix());
   CFX_DIBitmap* pBitmap = buffer.GetBitmap();
   if (pBitmap->GetBuffer() == NULL) {
     return;
   }
   pBitmap->Clear(background);
   int fill_mode = m_Options.m_Flags;
   switch (pPattern->m_ShadingType) {
     case kInvalidShading:
     case kMaxShading:
@@ skipping 31 matching lines @@
   if (bAlphaMode) {
     pBitmap->LoadChannel(FXDIB_Red, pBitmap, FXDIB_Alpha);
   }
   if (m_Options.m_ColorMode == RENDER_COLOR_GRAY) {
     pBitmap->ConvertColorScale(m_Options.m_ForeColor, m_Options.m_BackColor);
   }
   buffer.OutputToDevice();
 }
 void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern,
                                            CPDF_PageObject* pPageObj,
-                                           const CFX_AffineMatrix* pObj2Device,
+                                           const CFX_Matrix* pObj2Device,
                                            FX_BOOL bStroke) {
   if (!pattern->Load()) {
     return;
   }
   m_pDevice->SaveState();
   if (pPageObj->m_Type == PDFPAGE_PATH) {
     if (!SelectClipPath((CPDF_PathObject*)pPageObj, pObj2Device, bStroke)) {
       m_pDevice->RestoreState();
       return;
     }
   } else if (pPageObj->m_Type == PDFPAGE_IMAGE) {
     FX_RECT rect = pPageObj->GetBBox(pObj2Device);
     m_pDevice->SetClip_Rect(&rect);
   } else {
     return;
   }
   FX_RECT rect;
   if (GetObjectClippedRect(pPageObj, pObj2Device, FALSE, rect)) {
     m_pDevice->RestoreState();
     return;
   }
-  CFX_AffineMatrix matrix = pattern->m_Pattern2Form;
+  CFX_Matrix matrix = pattern->m_Pattern2Form;
   matrix.Concat(*pObj2Device);
   GetScaledMatrix(matrix);
   int alpha = pPageObj->m_GeneralState.GetAlpha(bStroke);
   DrawShading(pattern, &matrix, rect, alpha,
               m_Options.m_ColorMode == RENDER_COLOR_ALPHA);
   m_pDevice->RestoreState();
 }
 FX_BOOL CPDF_RenderStatus::ProcessShading(CPDF_ShadingObject* pShadingObj,
-                                          const CFX_AffineMatrix* pObj2Device) {
+                                          const CFX_Matrix* pObj2Device) {
   FX_RECT rect = pShadingObj->GetBBox(pObj2Device);
   FX_RECT clip_box = m_pDevice->GetClipBox();
   rect.Intersect(clip_box);
   if (rect.IsEmpty()) {
     return TRUE;
   }
-  CFX_AffineMatrix matrix = pShadingObj->m_Matrix;
+  CFX_Matrix matrix = pShadingObj->m_Matrix;
   matrix.Concat(*pObj2Device);
   DrawShading(pShadingObj->m_pShading, &matrix, rect,
               pShadingObj->m_GeneralState.GetAlpha(FALSE),
               m_Options.m_ColorMode == RENDER_COLOR_ALPHA);
   return TRUE;
 }
 static CFX_DIBitmap* DrawPatternBitmap(CPDF_Document* pDoc,
                                        CPDF_PageRenderCache* pCache,
                                        CPDF_TilingPattern* pPattern,
-                                       const CFX_AffineMatrix* pObject2Device,
+                                       const CFX_Matrix* pObject2Device,
                                        int width,
                                        int height,
                                        int flags) {
   CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
   if (!pBitmap->Create(width, height,
                        pPattern->m_bColored ? FXDIB_Argb : FXDIB_8bppMask)) {
     delete pBitmap;
     return NULL;
   }
   CFX_FxgeDevice bitmap_device;
   bitmap_device.Attach(pBitmap);
   pBitmap->Clear(0);
   CFX_FloatRect cell_bbox = pPattern->m_BBox;
   pPattern->m_Pattern2Form.TransformRect(cell_bbox);
   pObject2Device->TransformRect(cell_bbox);
   CFX_FloatRect bitmap_rect(0.0f, 0.0f, (FX_FLOAT)width, (FX_FLOAT)height);
-  CFX_AffineMatrix mtAdjust;
+  CFX_Matrix mtAdjust;
   mtAdjust.MatchRect(bitmap_rect, cell_bbox);
-  CFX_AffineMatrix mtPattern2Bitmap = *pObject2Device;
+  CFX_Matrix mtPattern2Bitmap = *pObject2Device;
   mtPattern2Bitmap.Concat(mtAdjust);
   CPDF_RenderOptions options;
   if (!pPattern->m_bColored) {
     options.m_ColorMode = RENDER_COLOR_ALPHA;
   }
   flags |= RENDER_FORCE_HALFTONE;
   options.m_Flags = flags;
   CPDF_RenderContext context;
   context.Create(pDoc, pCache, NULL);
   context.DrawObjectList(&bitmap_device, pPattern->m_pForm, &mtPattern2Bitmap,
                          &options);
   return pBitmap;
 }
 void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern,
                                           CPDF_PageObject* pPageObj,
-                                          const CFX_AffineMatrix* pObj2Device,
+                                          const CFX_Matrix* pObj2Device,
                                           FX_BOOL bStroke) {
   if (!pPattern->Load()) {
     return;
   }
   m_pDevice->SaveState();
   if (pPageObj->m_Type == PDFPAGE_PATH) {
     if (!SelectClipPath((CPDF_PathObject*)pPageObj, pObj2Device, bStroke)) {
       m_pDevice->RestoreState();
       return;
     }
   } else if (pPageObj->m_Type == PDFPAGE_IMAGE) {
     FX_RECT rect = pPageObj->GetBBox(pObj2Device);
     m_pDevice->SetClip_Rect(&rect);
   } else {
     return;
   }
   FX_RECT clip_box = m_pDevice->GetClipBox();
   if (clip_box.IsEmpty()) {
     m_pDevice->RestoreState();
     return;
   }
   CFX_Matrix dCTM = m_pDevice->GetCTM();
   FX_FLOAT sa = FXSYS_fabs(dCTM.a);
   FX_FLOAT sd = FXSYS_fabs(dCTM.d);
   clip_box.right = clip_box.left + (int32_t)FXSYS_ceil(clip_box.Width() * sa);
   clip_box.bottom = clip_box.top + (int32_t)FXSYS_ceil(clip_box.Height() * sd);
-  CFX_AffineMatrix mtPattern2Device = pPattern->m_Pattern2Form;
+  CFX_Matrix mtPattern2Device = pPattern->m_Pattern2Form;
   mtPattern2Device.Concat(*pObj2Device);
   GetScaledMatrix(mtPattern2Device);
   FX_BOOL bAligned = FALSE;
   if (pPattern->m_BBox.left == 0 && pPattern->m_BBox.bottom == 0 &&
       pPattern->m_BBox.right == pPattern->m_XStep &&
       pPattern->m_BBox.top == pPattern->m_YStep &&
       (mtPattern2Device.IsScaled() || mtPattern2Device.Is90Rotated())) {
     bAligned = TRUE;
   }
   CFX_FloatRect cell_bbox = pPattern->m_BBox;
   mtPattern2Device.TransformRect(cell_bbox);
   int width = (int)FXSYS_ceil(cell_bbox.Width());
   int height = (int)FXSYS_ceil(cell_bbox.Height());
   if (width == 0) {
     width = 1;
   }
   if (height == 0) {
     height = 1;
   }
   int min_col, max_col, min_row, max_row;
-  CFX_AffineMatrix mtDevice2Pattern;
+  CFX_Matrix mtDevice2Pattern;
   mtDevice2Pattern.SetReverse(mtPattern2Device);
   CFX_FloatRect clip_box_p(clip_box);
   clip_box_p.Transform(&mtDevice2Pattern);
   min_col = (int)FXSYS_ceil(
       FXSYS_Div(clip_box_p.left - pPattern->m_BBox.right, pPattern->m_XStep));
   max_col = (int)FXSYS_floor(
       FXSYS_Div(clip_box_p.right - pPattern->m_BBox.left, pPattern->m_XStep));
   min_row = (int)FXSYS_ceil(
       FXSYS_Div(clip_box_p.bottom - pPattern->m_BBox.top, pPattern->m_YStep));
   max_row = (int)FXSYS_floor(
       FXSYS_Div(clip_box_p.top - pPattern->m_BBox.bottom, pPattern->m_YStep));
   if (width > clip_box.Width() || height > clip_box.Height() ||
       width * height > clip_box.Width() * clip_box.Height()) {
     CPDF_GraphicStates* pStates = NULL;
     if (!pPattern->m_bColored) {
       pStates = CloneObjStates(pPageObj, bStroke);
     }
     CPDF_Dictionary* pFormResource = NULL;
     if (pPattern->m_pForm->m_pFormDict) {
       pFormResource =
           pPattern->m_pForm->m_pFormDict->GetDict(FX_BSTRC("Resources"));
     }
     for (int col = min_col; col <= max_col; col++)
       for (int row = min_row; row <= max_row; row++) {
         FX_FLOAT orig_x, orig_y;
         orig_x = col * pPattern->m_XStep;
         orig_y = row * pPattern->m_YStep;
         mtPattern2Device.Transform(orig_x, orig_y);
-        CFX_AffineMatrix matrix = *pObj2Device;
+        CFX_Matrix matrix = *pObj2Device;
         matrix.Translate(orig_x - mtPattern2Device.e,
                          orig_y - mtPattern2Device.f);
         m_pDevice->SaveState();
         CPDF_RenderStatus status;
         status.Initialize(m_pContext, m_pDevice, NULL, NULL, this, pStates,
                           &m_Options, pPattern->m_pForm->m_Transparency,
                           m_bDropObjects, pFormResource);
         status.RenderObjectList(pPattern->m_pForm, &matrix);
         m_pDevice->RestoreState();
       }
@@ skipping 88 matching lines @@
         }
       }
     }
   }
   CompositeDIBitmap(&screen, clip_box.left, clip_box.top, 0, 255,
                     FXDIB_BLEND_NORMAL, FALSE);
   m_pDevice->RestoreState();
   delete pPatternBitmap;
 }
 void CPDF_RenderStatus::DrawPathWithPattern(CPDF_PathObject* pPathObj,
-                                            const CFX_AffineMatrix* pObj2Device,
+                                            const CFX_Matrix* pObj2Device,
                                             CPDF_Color* pColor,
                                             FX_BOOL bStroke) {
   CPDF_Pattern* pattern = pColor->GetPattern();
   if (pattern == NULL) {
     return;
   }
   if (pattern->m_PatternType == PATTERN_TILING) {
     DrawTilingPattern((CPDF_TilingPattern*)pattern, pPathObj, pObj2Device,
                       bStroke);
   } else {
     DrawShadingPattern((CPDF_ShadingPattern*)pattern, pPathObj, pObj2Device,
                        bStroke);
   }
 }
 void CPDF_RenderStatus::ProcessPathPattern(CPDF_PathObject* pPathObj,
-                                           const CFX_AffineMatrix* pObj2Device,
+                                           const CFX_Matrix* pObj2Device,
                                            int& filltype,
                                            FX_BOOL& bStroke) {
   if (filltype) {
     CPDF_Color& FillColor = *pPathObj->m_ColorState.GetFillColor();
     if (FillColor.m_pCS && FillColor.m_pCS->GetFamily() == PDFCS_PATTERN) {
       DrawPathWithPattern(pPathObj, pObj2Device, &FillColor, FALSE);
       filltype = 0;
     }
   }
   if (bStroke) {
     CPDF_Color& StrokeColor = *pPathObj->m_ColorState.GetStrokeColor();
     if (StrokeColor.m_pCS && StrokeColor.m_pCS->GetFamily() == PDFCS_PATTERN) {
       DrawPathWithPattern(pPathObj, pObj2Device, &StrokeColor, TRUE);
       bStroke = FALSE;
     }
   }
 }