Simplify PDFium by removing code that's not used in the open source repo.

core/src/fpdfapi/fpdf_render/fpdf_render_image.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_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_render.h"
 #include "../../../include/fpdfapi/fpdf_pageobj.h"
 #include "../fpdf_page/pageint.h"
 #include "render_int.h"
 FX_BOOL CPDF_RenderStatus::ProcessImage(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pObj2Device)
 {
     CPDF_ImageRenderer render;
     if (render.Start(this, pImageObj, pObj2Device, m_bStdCS, m_curBlend)) {
         render.Continue(NULL);
     }
-#ifdef _FPDFAPI_MINI_
-    if (m_DitherBits) {
-        DitherObjectArea(pImageObj, pObj2Device);
-    }
-#endif
     return render.m_Result;
 }
-#if defined(_FPDFAPI_MINI_)
-FX_BOOL CPDF_RenderStatus::ProcessInlines(CPDF_InlineImages* pInlines, const CFX_AffineMatrix* pObj2Device)
-{
-    int bitmap_alpha = 255;
-    if (!pInlines->m_GeneralState.IsNull()) {
-        bitmap_alpha = FXSYS_round(pInlines->m_GeneralState.GetObject()->m_FillAlpha * 255);
-    }
-    if (pInlines->m_pStream) {
-        CPDF_DIBSource dibsrc;
-        if (!dibsrc.Load(m_pContext->m_pDocument, pInlines->m_pStream, NULL, NULL, NULL, NULL)) {
-            return TRUE;
-        }
-        pInlines->m_pBitmap = dibsrc.Clone();
-        pInlines->m_pStream->Release();
-        pInlines->m_pStream = NULL;
-    }
-    if (pInlines->m_pBitmap == NULL) {
-        return TRUE;
-    }
-    FX_ARGB fill_argb = 0;
-    if (pInlines->m_pBitmap->IsAlphaMask()) {
-        fill_argb = GetFillArgb(pInlines);
-    }
-    int flags = 0;
-    if (m_Options.m_Flags & RENDER_FORCE_DOWNSAMPLE) {
-        flags |= RENDER_FORCE_DOWNSAMPLE;
-    } else if (m_Options.m_Flags & RENDER_FORCE_HALFTONE) {
-        flags = 0;
-    }
-    for (int i = 0; i < pInlines->m_Matrices.GetSize(); i ++) {
-        CFX_AffineMatrix image_matrix = pInlines->m_Matrices.GetAt(i);
-        image_matrix.Concat(*pObj2Device);
-        CPDF_ImageRenderer renderer;
-        if (renderer.Start(this, pInlines->m_pBitmap, fill_argb, bitmap_alpha, &image_matrix, flags, FALSE, m_curBlend)) {
-            renderer.Continue(NULL);
-        }
-    }
-    return TRUE;
-}
-#endif
 void CPDF_RenderStatus::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap, int left, int top, FX_ARGB mask_argb,
         int bitmap_alpha, int blend_mode, int Transparency)
 {
     if (pDIBitmap == NULL) {
         return;
     }
     FX_BOOL bIsolated = Transparency & PDFTRANS_ISOLATED;
     FX_BOOL bGroup = Transparency & PDFTRANS_GROUP;
     if (blend_mode == FXDIB_BLEND_NORMAL) {
         if (!pDIBitmap->IsAlphaMask()) {
@@ skipping 308 matching lines @@
     }
     m_BitmapAlpha = 255;
     const CPDF_GeneralStateData* pGeneralState = m_pImageObject->m_GeneralState;
     if (pGeneralState) {
         m_BitmapAlpha = FXSYS_round(pGeneralState->m_FillAlpha * 255);
     }
     m_pDIBSource = m_Loader.m_pBitmap;
     if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_ALPHA && m_Loader.m_pMask == NULL) {
         return StartBitmapAlpha();
     }
-#ifndef _FPDFAPI_MINI_
     if (pGeneralState && pGeneralState->m_pTR) {
         if (!pGeneralState->m_pTransferFunc) {
             ((CPDF_GeneralStateData*)pGeneralState)->m_pTransferFunc = m_pRenderStatus->GetTransferFunc(pGeneralState->m_pTR);
         }
         if (pGeneralState->m_pTransferFunc && !pGeneralState->m_pTransferFunc->m_bIdentity) {
             m_pDIBSource = m_Loader.m_pBitmap = pGeneralState->m_pTransferFunc->TranslateImage(m_Loader.m_pBitmap, !m_Loader.m_bCached);
             if (m_Loader.m_bCached && m_Loader.m_pMask) {
                 m_Loader.m_pMask = m_Loader.m_pMask->Clone();
             }
             m_Loader.m_bCached = FALSE;
         }
     }
-#endif
     m_FillArgb = 0;
     m_bPatternColor = FALSE;
     m_pPattern = NULL;
     if (m_pDIBSource->IsAlphaMask()) {
         CPDF_Color* pColor = m_pImageObject->m_ColorState.GetFillColor();
         if (pColor && pColor->IsPattern()) {
             m_pPattern = pColor->GetPattern();
             if (m_pPattern != NULL) {
                 m_bPatternColor = TRUE;
             }
         }
         m_FillArgb = m_pRenderStatus->GetFillArgb(m_pImageObject);
     } else if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_GRAY) {
         m_pClone = m_pDIBSource->Clone();
         m_pClone->ConvertColorScale(m_pRenderStatus->m_Options.m_BackColor, m_pRenderStatus->m_Options.m_ForeColor);
         m_pDIBSource = m_pClone;
     }
     m_Flags = 0;
-#if !defined(_FPDFAPI_MINI_)
     if (m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_DOWNSAMPLE) {
         m_Flags |= RENDER_FORCE_DOWNSAMPLE;
     } else if (m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_HALFTONE) {
         m_Flags |= RENDER_FORCE_HALFTONE;
     }
-#else
-    if (!(m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_HALFTONE)) {
-        if (m_pRenderStatus->m_HalftoneLimit) {
-            CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
-            FX_RECT image_rect = image_rect_f.GetOutterRect();
-            FX_RECT image_clip = image_rect;
-            image_rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
-            if (image_rect.Width() && image_rect.Height()) {
-                if ((image_clip.Width() * m_pDIBSource->GetWidth() / image_rect.Width()) *
-                        (image_clip.Height() * m_pDIBSource->GetHeight() / image_rect.Height()) >
-                        m_pRenderStatus->m_HalftoneLimit) {
-                    m_Flags |= RENDER_FORCE_DOWNSAMPLE;
-                }
-            }
-        } else {
-            m_Flags |= RENDER_FORCE_DOWNSAMPLE;
-        }
-    }
-#endif
-#ifndef _FPDFAPI_MINI_
     if (m_pRenderStatus->m_pDevice->GetDeviceClass() != FXDC_DISPLAY) {
         CPDF_Object* pFilters = m_pImageObject->m_pImage->GetStream()->GetDict()->GetElementValue(FX_BSTRC("Filter"));
         if (pFilters) {
             if (pFilters->GetType() == PDFOBJ_NAME) {
                 CFX_ByteStringC bsDecodeType = pFilters->GetConstString();
                 if (bsDecodeType == FX_BSTRC("DCTDecode") || bsDecodeType == FX_BSTRC("JPXDecode")) {
                     m_Flags |= FXRENDER_IMAGE_LOSSY;
                 }
             } else if (pFilters->GetType() == PDFOBJ_ARRAY) {
                 CPDF_Array* pArray = (CPDF_Array*)pFilters;
                 for (FX_DWORD i = 0; i < pArray->GetCount(); i ++) {
                     CFX_ByteStringC bsDecodeType = pArray->GetConstString(i);
                     if (bsDecodeType == FX_BSTRC("DCTDecode") || bsDecodeType == FX_BSTRC("JPXDecode")) {
                         m_Flags |= FXRENDER_IMAGE_LOSSY;
                         break;
                     }
                 }
             }
         }
     }
     if (m_pRenderStatus->m_Options.m_Flags & RENDER_NOIMAGESMOOTH) {
         m_Flags |= FXDIB_NOSMOOTH;
     } else if (m_pImageObject->m_pImage->IsInterpol()) {
         m_Flags |= FXDIB_INTERPOL;
     }
-#endif
     if (m_Loader.m_pMask) {
         return DrawMaskedImage();
     }
     if (m_bPatternColor) {
         return DrawPatternImage(m_pObj2Device);
     }
-#if !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
     if (m_BitmapAlpha == 255 && pGeneralState && pGeneralState->m_FillOP &&
             pGeneralState->m_OPMode == 0 && pGeneralState->m_BlendType == FXDIB_BLEND_NORMAL && pGeneralState->m_StrokeAlpha == 1 && pGeneralState->m_FillAlpha == 1) {
         CPDF_Document* pDocument = NULL;
         CPDF_Page* pPage = NULL;
         if (m_pRenderStatus->m_pContext->m_pPageCache) {
             pPage = m_pRenderStatus->m_pContext->m_pPageCache->GetPage();
             pDocument = pPage->m_pDocument;
         } else {
             pDocument = m_pImageObject->m_pImage->GetDocument();
         }
         CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : NULL;
         CPDF_Object* pCSObj = m_pImageObject->m_pImage->GetStream()->GetDict()->GetElementValue(FX_BSTRC("ColorSpace"));
         CPDF_ColorSpace* pColorSpace = pDocument->LoadColorSpace(pCSObj, pPageResources);
         if (pColorSpace) {
             int format = pColorSpace->GetFamily();
             if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION || format == PDFCS_DEVICEN) {
                 m_BlendType = FXDIB_BLEND_DARKEN;
             }
             pDocument->GetPageData()->ReleaseColorSpace(pCSObj);
         }
     }
-#endif
     return StartDIBSource();
 }
 FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStdCS, int blendType)
 {
     m_pRenderStatus = pStatus;
     m_bStdCS = bStdCS;
     m_pImageObject = (CPDF_ImageObject*)pObj;
     m_BlendType = blendType;
     m_pObj2Device = pObj2Device;
-#ifndef _FPDFAPI_MINI_
     CPDF_Dictionary* pOC = m_pImageObject->m_pImage->GetOC();
     if (pOC && m_pRenderStatus->m_Options.m_pOCContext && !m_pRenderStatus->m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
         return FALSE;
     }
-#endif
     m_ImageMatrix = m_pImageObject->m_Matrix;
     m_ImageMatrix.Concat(*pObj2Device);
     if (StartLoadDIBSource()) {
         return TRUE;
     }
     return StartRenderDIBSource();
 }
 FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, const CFX_DIBSource* pDIBSource, FX_ARGB bitmap_argb,
                                   int bitmap_alpha, const CFX_AffineMatrix* pImage2Device, FX_DWORD flags, FX_BOOL bStdCS, int blendType)
 {
@@ skipping 181 matching lines @@
         bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
         if (m_BitmapAlpha < 255) {
             bitmap_device1.GetBitmap()->MultiplyAlpha(m_BitmapAlpha);
         }
     }
     m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
     return FALSE;
 }
 FX_BOOL CPDF_ImageRenderer::StartDIBSource()
 {
-#if !defined(_FPDFAPI_MINI_)
     if (!(m_Flags & RENDER_FORCE_DOWNSAMPLE) && m_pDIBSource->GetBPP() > 1) {
         int image_size = m_pDIBSource->GetBPP() / 8 * m_pDIBSource->GetWidth() * m_pDIBSource->GetHeight();
         if (image_size > FPDF_HUGE_IMAGE_SIZE && !(m_Flags & RENDER_FORCE_HALFTONE)) {
             m_Flags |= RENDER_FORCE_DOWNSAMPLE;
         }
     }
-#endif
     if (m_pRenderStatus->m_pDevice->StartDIBits(m_pDIBSource, m_BitmapAlpha, m_FillArgb,
             &m_ImageMatrix, m_Flags, m_DeviceHandle, 0, NULL, m_BlendType)) {
         if (m_DeviceHandle != NULL) {
             m_Status = 3;
             return TRUE;
         }
         return FALSE;
     }
-#if !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
     CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
     FX_RECT image_rect = image_rect_f.GetOutterRect();
     int dest_width = image_rect.Width();
     int dest_height = image_rect.Height();
     if ((FXSYS_fabs(m_ImageMatrix.b) >= 0.5f || m_ImageMatrix.a == 0) ||
             (FXSYS_fabs(m_ImageMatrix.c) >= 0.5f || m_ImageMatrix.d == 0) ) {
         if (m_pRenderStatus->m_bPrint && !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
             m_Result = FALSE;
             return FALSE;
         }
@@ skipping 36 matching lines @@
     dest_rect.Intersect(image_rect);
     FX_RECT dest_clip(dest_rect.left - image_rect.left, dest_rect.top - image_rect.top,
                       dest_rect.right - image_rect.left, dest_rect.bottom - image_rect.top);
     CFX_DIBitmap* pStretched = m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip);
     if (pStretched) {
         m_pRenderStatus->CompositeDIBitmap(pStretched, dest_rect.left, dest_rect.top, m_FillArgb,
                                            m_BitmapAlpha, m_BlendType, FALSE);
         delete pStretched;
         pStretched = NULL;
     }
-#endif
     return FALSE;
 }
 FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha()
 {
-#ifndef _FPDFAPI_MINI_
     if (m_pDIBSource->IsOpaqueImage()) {
         CFX_PathData path;
         path.AppendRect(0, 0, 1, 1);
         path.Transform(&m_ImageMatrix);
         FX_DWORD fill_color = ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha);
         m_pRenderStatus->m_pDevice->DrawPath(&path, NULL, NULL, fill_color, 0, FXFILL_WINDING);
     } else {
         const CFX_DIBSource* pAlphaMask = m_pDIBSource->IsAlphaMask() ? m_pDIBSource : m_pDIBSource->GetAlphaMask();
         if (FXSYS_fabs(m_ImageMatrix.b) >= 0.5f || FXSYS_fabs(m_ImageMatrix.c) >= 0.5f) {
             int left, top;
@@ skipping 10 matching lines @@
             int dest_height = m_ImageMatrix.d > 0 ? -image_rect.Height() : image_rect.Height();
             int left = dest_width > 0 ? image_rect.left : image_rect.right;
             int top = dest_height > 0 ? image_rect.top : image_rect.bottom;
             m_pRenderStatus->m_pDevice->StretchBitMask(pAlphaMask, left, top, dest_width, dest_height,
                     ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
         }
         if (m_pDIBSource != pAlphaMask) {
             delete pAlphaMask;
         }
     }
-#endif
     return FALSE;
 }
 FX_BOOL CPDF_ImageRenderer::Continue(IFX_Pause* pPause)
 {
     if (m_Status == 1) {
-#ifndef _FPDFAPI_MINI_
         if (m_pQuickStretcher->Continue(pPause)) {
             return TRUE;
         }
         if (m_pQuickStretcher->m_pBitmap->IsAlphaMask())
             m_pRenderStatus->m_pDevice->SetBitMask(m_pQuickStretcher->m_pBitmap, m_pQuickStretcher->m_ResultLeft,
                                                    m_pQuickStretcher->m_ResultTop, m_FillArgb);
         else
             m_pRenderStatus->m_pDevice->SetDIBits(m_pQuickStretcher->m_pBitmap, m_pQuickStretcher->m_ResultLeft,
                                                   m_pQuickStretcher->m_ResultTop, m_BlendType);
         return FALSE;
-#endif
     } else if (m_Status == 2) {
-#if !defined(_FPDFAPI_MINI_) || defined(_FXCORE_FEATURE_ALL_)
         if (m_pTransformer->Continue(pPause)) {
             return TRUE;
         }
         CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
         if (pBitmap == NULL) {
             return FALSE;
         }
         if (pBitmap->IsAlphaMask()) {
             if (m_BitmapAlpha != 255) {
                 m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
             }
             m_Result = m_pRenderStatus->m_pDevice->SetBitMask(pBitmap,
                        m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop, m_FillArgb);
         } else {
             if (m_BitmapAlpha != 255) {
                 pBitmap->MultiplyAlpha(m_BitmapAlpha);
             }
             m_Result = m_pRenderStatus->m_pDevice->SetDIBits(pBitmap,
                        m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop, m_BlendType);
         }
         delete pBitmap;
         return FALSE;
-#endif
     } else if (m_Status == 3) {
         return m_pRenderStatus->m_pDevice->ContinueDIBits(m_DeviceHandle, pPause);
     } else if (m_Status == 4) {
         if (m_Loader.Continue(m_LoadHandle, pPause)) {
             return TRUE;
         }
         if (StartRenderDIBSource()) {
             return Continue(pPause);
         }
         return FALSE;
@@ skipping 274 matching lines @@
         }
     } else {
         FXSYS_memcpy32(dest_buf, src_buf, dest_pitch * height);
     }
     if (pFunc) {
         delete pFunc;
     }
     FX_Free(pTransfer);
     return pMask;
 }