Merge to XFA: Add type cast definitions for CPDF_Stream.

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 "../../../include/fpdfapi/fpdf_render.h"
 #include "../../../include/fpdfapi/fpdf_pageobj.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../fpdf_page/pageint.h"
 #include "render_int.h"
 #define SHADING_STEPS 256
-static void _DrawAxialShading(CFX_DIBitmap* pBitmap,
-                              CFX_AffineMatrix* pObject2Bitmap,
-                              CPDF_Dictionary* pDict,
-                              CPDF_Function** pFuncs,
-                              int nFuncs,
-                              CPDF_ColorSpace* pCS,
-                              int alpha) {
+static void DrawAxialShading(CFX_DIBitmap* pBitmap,
+                             CFX_AffineMatrix* 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 end_x = pCoords->GetNumber(2);
   FX_FLOAT end_y = pCoords->GetNumber(3);
   FX_FLOAT t_min = 0, t_max = 1.0f;
@@ skipping 64 matching lines @@
       } else if (index >= SHADING_STEPS) {
         if (!bEndExtend) {
           continue;
         }
         index = SHADING_STEPS - 1;
       }
       dib_buf[column] = rgb_array[index];
     }
   }
 }
-static void _DrawRadialShading(CFX_DIBitmap* pBitmap,
-                               CFX_AffineMatrix* pObject2Bitmap,
-                               CPDF_Dictionary* pDict,
-                               CPDF_Function** pFuncs,
-                               int nFuncs,
-                               CPDF_ColorSpace* pCS,
-                               int alpha) {
+static void DrawRadialShading(CFX_DIBitmap* pBitmap,
+                              CFX_AffineMatrix* 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);
@@ skipping 111 matching lines @@
       if (index >= SHADING_STEPS) {
         if (!bEndExtend) {
           continue;
         }
         index = SHADING_STEPS - 1;
       }
       dib_buf[column] = rgb_array[index];
     }
   }
 }
-static void _DrawFuncShading(CFX_DIBitmap* pBitmap,
-                             CFX_AffineMatrix* pObject2Bitmap,
-                             CPDF_Dictionary* pDict,
-                             CPDF_Function** pFuncs,
-                             int nFuncs,
-                             CPDF_ColorSpace* pCS,
-                             int alpha) {
+static void DrawFuncShading(CFX_DIBitmap* pBitmap,
+                            CFX_AffineMatrix* 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"));
@@ skipping 57 matching lines @@
       return FALSE;
     }
   } else {
     if (y < y2 || y > y1) {
       return FALSE;
     }
   }
   x = x1 + FXSYS_MulDiv(x2 - x1, y - y1, y2 - y1);
   return TRUE;
 }
-static void _DrawGouraud(CFX_DIBitmap* pBitmap,
-                         int alpha,
-                         CPDF_MeshVertex triangle[3]) {
+static void DrawGouraud(CFX_DIBitmap* pBitmap,
+                        int alpha,
+                        CPDF_MeshVertex triangle[3]) {
   FX_FLOAT min_y = triangle[0].y, max_y = triangle[0].y;
   for (int i = 1; i < 3; i++) {
     if (min_y > triangle[i].y) {
       min_y = triangle[i].y;
     }
     if (max_y < triangle[i].y) {
       max_y = triangle[i].y;
     }
   }
   if (min_y == max_y) {
@@ skipping 62 matching lines @@
       R += r_unit;
       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,
-                                    CPDF_Stream* pShadingStream,
-                                    CPDF_Function** pFuncs,
-                                    int nFuncs,
-                                    CPDF_ColorSpace* pCS,
-                                    int alpha) {
+static void DrawFreeGouraudShading(CFX_DIBitmap* pBitmap,
+                                   CFX_AffineMatrix* pObject2Bitmap,
+                                   CPDF_Stream* pShadingStream,
+                                   CPDF_Function** pFuncs,
+                                   int nFuncs,
+                                   CPDF_ColorSpace* pCS,
+                                   int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
-  if (pShadingStream->GetType() != PDFOBJ_STREAM) {
+
+  CPDF_MeshStream stream;
+  if (!stream.Load(pShadingStream, pFuncs, nFuncs, pCS))
     return;
-  }
-  CPDF_MeshStream stream;
-  if (!stream.Load(pShadingStream, pFuncs, nFuncs, pCS)) {
-    return;
-  }
+
   CPDF_MeshVertex triangle[3];
   FXSYS_memset(triangle, 0, sizeof(triangle));
 
   while (!stream.m_BitStream.IsEOF()) {
     CPDF_MeshVertex vertex;
     FX_DWORD flag = stream.GetVertex(vertex, pObject2Bitmap);
     if (flag == 0) {
       triangle[0] = vertex;
       for (int j = 1; j < 3; j++) {
         stream.GetVertex(triangle[j], pObject2Bitmap);
       }
     } else {
       if (flag == 1) {
         triangle[0] = triangle[1];
       }
       triangle[1] = triangle[2];
       triangle[2] = vertex;
     }
-    _DrawGouraud(pBitmap, alpha, triangle);
+    DrawGouraud(pBitmap, alpha, triangle);
   }
 }
-static void _DrawLatticeGouraudShading(CFX_DIBitmap* pBitmap,
-                                       CFX_AffineMatrix* pObject2Bitmap,
-                                       CPDF_Stream* pShadingStream,
-                                       CPDF_Function** pFuncs,
-                                       int nFuncs,
-                                       CPDF_ColorSpace* pCS,
-                                       int alpha) {
+static void DrawLatticeGouraudShading(CFX_DIBitmap* pBitmap,
+                                      CFX_AffineMatrix* pObject2Bitmap,
+                                      CPDF_Stream* pShadingStream,
+                                      CPDF_Function** pFuncs,
+                                      int nFuncs,
+                                      CPDF_ColorSpace* pCS,
+                                      int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
-  if (pShadingStream->GetType() != PDFOBJ_STREAM) {
+
+  int row_verts = pShadingStream->GetDict()->GetInteger("VerticesPerRow");
+  if (row_verts < 2)
     return;
-  }
-  int row_verts = pShadingStream->GetDict()->GetInteger("VerticesPerRow");
-  if (row_verts < 2) {
+
+  CPDF_MeshStream stream;
+  if (!stream.Load(pShadingStream, pFuncs, nFuncs, pCS))
     return;
-  }
-  CPDF_MeshStream stream;
-  if (!stream.Load(pShadingStream, pFuncs, nFuncs, pCS)) {
-    return;
-  }
+
   CPDF_MeshVertex* vertex = FX_Alloc2D(CPDF_MeshVertex, row_verts, 2);
   if (!stream.GetVertexRow(vertex, row_verts, pObject2Bitmap)) {
     FX_Free(vertex);
     return;
   }
   int last_index = 0;
   while (1) {
     CPDF_MeshVertex* last_row = vertex + last_index * row_verts;
     CPDF_MeshVertex* this_row = vertex + (1 - last_index) * row_verts;
     if (!stream.GetVertexRow(this_row, row_verts, pObject2Bitmap)) {
       FX_Free(vertex);
       return;
     }
     CPDF_MeshVertex triangle[3];
     for (int i = 1; i < row_verts; i++) {
       triangle[0] = last_row[i];
       triangle[1] = this_row[i - 1];
       triangle[2] = last_row[i - 1];
-      _DrawGouraud(pBitmap, alpha, triangle);
+      DrawGouraud(pBitmap, alpha, triangle);
       triangle[2] = this_row[i];
-      _DrawGouraud(pBitmap, alpha, triangle);
+      DrawGouraud(pBitmap, alpha, triangle);
     }
     last_index = 1 - last_index;
   }
   FX_Free(vertex);
 }
 struct Coon_BezierCoeff {
   float a, b, c, d;
   void FromPoints(float p0, float p1, float p2, float p3) {
     a = -p0 + 3 * p1 - 3 * p2 + p3;
     b = 3 * p0 - 6 * p1 + 3 * p2;
@@ skipping 244 matching lines @@
   FX_BOOL bCompBits = (stream.m_nCompBits == 1 || stream.m_nCompBits == 2 ||
                        stream.m_nCompBits == 4 || stream.m_nCompBits == 8 ||
                        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,
-                                 CPDF_Stream* pShadingStream,
-                                 CPDF_Function** pFuncs,
-                                 int nFuncs,
-                                 CPDF_ColorSpace* pCS,
-                                 int fill_mode,
-                                 int alpha) {
+static void DrawCoonPatchMeshes(FX_BOOL bTensor,
+                                CFX_DIBitmap* pBitmap,
+                                CFX_AffineMatrix* pObject2Bitmap,
+                                CPDF_Stream* pShadingStream,
+                                CPDF_Function** pFuncs,
+                                int nFuncs,
+                                CPDF_ColorSpace* pCS,
+                                int fill_mode,
+                                int alpha) {
   ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
-  if (pShadingStream->GetType() != PDFOBJ_STREAM) {
-    return;
-  }
+
   CFX_FxgeDevice device;
   device.Attach(pBitmap);
   CPDF_MeshStream stream;
-  if (!stream.Load(pShadingStream, pFuncs, nFuncs, pCS)) {
+  if (!stream.Load(pShadingStream, pFuncs, nFuncs, pCS))
     return;
-  }
-
-  if (!_CheckCoonTensorPara(stream)) {
+  if (!_CheckCoonTensorPara(stream))
     return;
-  }
 
   CPDF_PatchDrawer patch;
   patch.alpha = alpha;
   patch.pDevice = &device;
   patch.fill_mode = fill_mode;
   patch.path.SetPointCount(13);
   FX_PATHPOINT* pPoints = patch.path.GetPoints();
   pPoints[0].m_Flag = FXPT_MOVETO;
   for (int i = 1; i < 13; i++) {
     pPoints[i].m_Flag = FXPT_BEZIERTO;
@@ skipping 87 matching lines @@
   CFX_AffineMatrix 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 1:
-      _DrawFuncShading(pBitmap, &FinalMatrix, pDict, pFuncs, nFuncs,
+      DrawFuncShading(pBitmap, &FinalMatrix, pDict, pFuncs, nFuncs, pColorSpace,
+                      alpha);
+      break;
+    case 2:
+      DrawAxialShading(pBitmap, &FinalMatrix, pDict, pFuncs, nFuncs,
                        pColorSpace, alpha);
       break;
-    case 2:
-      _DrawAxialShading(pBitmap, &FinalMatrix, pDict, pFuncs, nFuncs,
+    case 3:
+      DrawRadialShading(pBitmap, &FinalMatrix, pDict, pFuncs, nFuncs,
                         pColorSpace, alpha);
       break;
-    case 3:
-      _DrawRadialShading(pBitmap, &FinalMatrix, pDict, pFuncs, nFuncs,
-                         pColorSpace, alpha);
-      break;
     case 4: {
-      _DrawFreeGouraudShading(pBitmap, &FinalMatrix,
-                              (CPDF_Stream*)pPattern->m_pShadingObj, pFuncs,
-                              nFuncs, pColorSpace, alpha);
+      DrawFreeGouraudShading(pBitmap, &FinalMatrix,
+                             ToStream(pPattern->m_pShadingObj), pFuncs, nFuncs,
+                             pColorSpace, alpha);
     } break;
     case 5: {
-      _DrawLatticeGouraudShading(pBitmap, &FinalMatrix,
-                                 (CPDF_Stream*)pPattern->m_pShadingObj, pFuncs,
-                                 nFuncs, pColorSpace, alpha);
+      DrawLatticeGouraudShading(pBitmap, &FinalMatrix,
+                                ToStream(pPattern->m_pShadingObj), pFuncs,
+                                nFuncs, pColorSpace, alpha);
     } break;
     case 6:
     case 7: {
-      _DrawCoonPatchMeshes(pPattern->m_ShadingType - 6, pBitmap, &FinalMatrix,
-                           (CPDF_Stream*)pPattern->m_pShadingObj, pFuncs,
-                           nFuncs, pColorSpace, fill_mode, alpha);
+      DrawCoonPatchMeshes(pPattern->m_ShadingType - 6, pBitmap, &FinalMatrix,
+                          ToStream(pPattern->m_pShadingObj), pFuncs, nFuncs,
+                          pColorSpace, fill_mode, alpha);
     } break;
   }
   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();
 }
@@ skipping 295 matching lines @@
     }
   }
   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;
     }
   }
 }