xref: /aosp_15_r20/external/pdfium/core/fxge/agg/fx_agg_driver.cpp (revision 3ac0a46f773bac49fa9476ec2b1cf3f8da5ec3a4) 
1 // Copyright 2014 The PDFium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 
7 #include "core/fxge/agg/fx_agg_driver.h"
8 
9 #include <math.h>
10 #include <stdint.h>
11 
12 #include <algorithm>
13 #include <utility>
14 
15 #include "build/build_config.h"
16 #include "core/fxcrt/fx_2d_size.h"
17 #include "core/fxcrt/fx_safe_types.h"
18 #include "core/fxcrt/unowned_ptr_exclusion.h"
19 #include "core/fxge/cfx_cliprgn.h"
20 #include "core/fxge/cfx_defaultrenderdevice.h"
21 #include "core/fxge/cfx_graphstatedata.h"
22 #include "core/fxge/cfx_path.h"
23 #include "core/fxge/dib/cfx_dibitmap.h"
24 #include "core/fxge/dib/cfx_imagerenderer.h"
25 #include "core/fxge/dib/cfx_imagestretcher.h"
26 #include "third_party/base/check.h"
27 #include "third_party/base/check_op.h"
28 #include "third_party/base/containers/span.h"
29 #include "third_party/base/notreached.h"
30 
31 // Ignore fallthrough warnings in agg23 headers.
32 #if defined(__clang__)
33 #pragma GCC diagnostic push
34 #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
35 #endif
36 #include "third_party/agg23/agg_clip_liang_barsky.h"
37 #include "third_party/agg23/agg_conv_dash.h"
38 #include "third_party/agg23/agg_conv_stroke.h"
39 #include "third_party/agg23/agg_curves.h"
40 #include "third_party/agg23/agg_path_storage.h"
41 #include "third_party/agg23/agg_pixfmt_gray.h"
42 #include "third_party/agg23/agg_rasterizer_scanline_aa.h"
43 #include "third_party/agg23/agg_renderer_scanline.h"
44 #include "third_party/agg23/agg_scanline_u.h"
45 #if defined(__clang__)
46 #pragma GCC diagnostic pop
47 #endif
48 
49 namespace pdfium {
50 namespace {
51 
52 const float kMaxPos = 32000.0f;
53 
HardClip(const CFX_PointF & pos)54 CFX_PointF HardClip(const CFX_PointF& pos) {
55   return CFX_PointF(std::clamp(pos.x, -kMaxPos, kMaxPos),
56                     std::clamp(pos.y, -kMaxPos, kMaxPos));
57 }
58 
RgbByteOrderCompositeRect(const RetainPtr<CFX_DIBitmap> & pBitmap,int left,int top,int width,int height,FX_ARGB argb)59 void RgbByteOrderCompositeRect(const RetainPtr<CFX_DIBitmap>& pBitmap,
60                                int left,
61                                int top,
62                                int width,
63                                int height,
64                                FX_ARGB argb) {
65   int src_alpha = FXARGB_A(argb);
66   if (src_alpha == 0)
67     return;
68 
69   FX_RECT rect(left, top, left + width, top + height);
70   rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
71   width = rect.Width();
72   int src_r = FXARGB_R(argb);
73   int src_g = FXARGB_G(argb);
74   int src_b = FXARGB_B(argb);
75   int Bpp = pBitmap->GetBPP() / 8;
76   int dib_argb = FXARGB_TOBGRORDERDIB(argb);
77   pdfium::span<uint8_t> pBuffer = pBitmap->GetWritableBuffer();
78   if (src_alpha == 255) {
79     for (int row = rect.top; row < rect.bottom; row++) {
80       uint8_t* dest_scan =
81           pBuffer.subspan(row * pBitmap->GetPitch() + rect.left * Bpp).data();
82       if (Bpp == 4) {
83         std::fill_n(reinterpret_cast<uint32_t*>(dest_scan), width, dib_argb);
84       } else {
85         for (int col = 0; col < width; col++) {
86           *dest_scan++ = src_r;
87           *dest_scan++ = src_g;
88           *dest_scan++ = src_b;
89         }
90       }
91     }
92     return;
93   }
94   bool bAlpha = pBitmap->IsAlphaFormat();
95   for (int row = rect.top; row < rect.bottom; row++) {
96     uint8_t* dest_scan =
97         pBuffer.subspan(row * pBitmap->GetPitch() + rect.left * Bpp).data();
98     if (bAlpha) {
99       for (int col = 0; col < width; col++) {
100         uint8_t back_alpha = dest_scan[3];
101         if (back_alpha == 0) {
102           FXARGB_SETRGBORDERDIB(dest_scan, argb);
103           dest_scan += 4;
104           continue;
105         }
106         uint8_t dest_alpha =
107             back_alpha + src_alpha - back_alpha * src_alpha / 255;
108         dest_scan[3] = dest_alpha;
109         int alpha_ratio = src_alpha * 255 / dest_alpha;
110         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
111         dest_scan++;
112         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
113         dest_scan++;
114         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
115         dest_scan += 2;
116       }
117       continue;
118     }
119     for (int col = 0; col < width; col++) {
120       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
121       dest_scan++;
122       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
123       dest_scan++;
124       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
125       dest_scan++;
126       if (Bpp == 4)
127         dest_scan++;
128     }
129   }
130 }
131 
RgbByteOrderTransferBitmap(const RetainPtr<CFX_DIBitmap> & pBitmap,int width,int height,const RetainPtr<CFX_DIBBase> & pSrcBitmap,int src_left,int src_top)132 void RgbByteOrderTransferBitmap(const RetainPtr<CFX_DIBitmap>& pBitmap,
133                                 int width,
134                                 int height,
135                                 const RetainPtr<CFX_DIBBase>& pSrcBitmap,
136                                 int src_left,
137                                 int src_top) {
138   int dest_left = 0;
139   int dest_top = 0;
140   if (!pBitmap->GetOverlapRect(dest_left, dest_top, width, height,
141                                pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(),
142                                src_left, src_top, nullptr)) {
143     return;
144   }
145 
146   const int Bpp = pBitmap->GetBPP() / 8;
147   const FXDIB_Format dest_format = pBitmap->GetFormat();
148   const FXDIB_Format src_format = pSrcBitmap->GetFormat();
149   const int dest_pitch = pBitmap->GetPitch();
150 
151   const size_t dest_x_offset = Fx2DSizeOrDie(dest_left, Bpp);
152   const size_t dest_y_offset = Fx2DSizeOrDie(dest_top, dest_pitch);
153 
154   pdfium::span<uint8_t> dest_span = pBitmap->GetWritableBuffer()
155                                         .subspan(dest_y_offset)
156                                         .subspan(dest_x_offset);
157   if (dest_format == src_format) {
158     const size_t src_x_offset = Fx2DSizeOrDie(src_left, Bpp);
159     for (int row = 0; row < height; row++) {
160       uint8_t* dest_scan = dest_span.data();
161       const uint8_t* src_scan =
162           pSrcBitmap->GetScanline(src_top + row).subspan(src_x_offset).data();
163       if (Bpp == 4) {
164         for (int col = 0; col < width; col++) {
165           FXARGB_SETRGBORDERDIB(dest_scan,
166                                 *reinterpret_cast<const uint32_t*>(src_scan));
167           dest_scan += 4;
168           src_scan += 4;
169         }
170       } else {
171         for (int col = 0; col < width; col++) {
172           *dest_scan++ = src_scan[2];
173           *dest_scan++ = src_scan[1];
174           *dest_scan++ = src_scan[0];
175           src_scan += 3;
176         }
177       }
178       dest_span = dest_span.subspan(dest_pitch);
179     }
180     return;
181   }
182 
183   if (dest_format == FXDIB_Format::kRgb) {
184     DCHECK_EQ(src_format, FXDIB_Format::kRgb32);
185     const size_t src_x_offset = Fx2DSizeOrDie(src_left, 4);
186     for (int row = 0; row < height; row++) {
187       uint8_t* dest_scan = dest_span.data();
188       const uint8_t* src_scan =
189           pSrcBitmap->GetScanline(src_top + row).subspan(src_x_offset).data();
190       for (int col = 0; col < width; col++) {
191         *dest_scan++ = src_scan[2];
192         *dest_scan++ = src_scan[1];
193         *dest_scan++ = src_scan[0];
194         src_scan += 4;
195       }
196       if (row < height - 1) {
197         // Since `dest_scan` was initialized in a way that takes `dest_x_offset`
198         // and `dest_y_offset` into account, it may go past the end of the span
199         // after processing the last row.
200         dest_span = dest_span.subspan(dest_pitch);
201       }
202     }
203     return;
204   }
205 
206   DCHECK(dest_format == FXDIB_Format::kArgb ||
207          dest_format == FXDIB_Format::kRgb32);
208   if (src_format == FXDIB_Format::kRgb) {
209     const size_t src_x_offset = Fx2DSizeOrDie(src_left, 3);
210     for (int row = 0; row < height; row++) {
211       uint8_t* dest_scan = dest_span.data();
212       const uint8_t* src_scan =
213           pSrcBitmap->GetScanline(src_top + row).subspan(src_x_offset).data();
214       for (int col = 0; col < width; col++) {
215         FXARGB_SETDIB(dest_scan,
216                       ArgbEncode(0xff, src_scan[0], src_scan[1], src_scan[2]));
217         dest_scan += 4;
218         src_scan += 3;
219       }
220       dest_span = dest_span.subspan(dest_pitch);
221     }
222     return;
223   }
224   if (src_format != FXDIB_Format::kRgb32)
225     return;
226   DCHECK_EQ(dest_format, FXDIB_Format::kArgb);
227   const size_t src_x_offset = Fx2DSizeOrDie(src_left, 4);
228   for (int row = 0; row < height; row++) {
229     uint8_t* dest_scan = dest_span.data();
230     const uint8_t* src_scan =
231         pSrcBitmap->GetScanline(src_top + row).subspan(src_x_offset).data();
232     for (int col = 0; col < width; col++) {
233       FXARGB_SETDIB(dest_scan,
234                     ArgbEncode(0xff, src_scan[0], src_scan[1], src_scan[2]));
235       src_scan += 4;
236       dest_scan += 4;
237     }
238     dest_span = dest_span.subspan(dest_pitch);
239   }
240 }
241 
RasterizeStroke(agg::rasterizer_scanline_aa * rasterizer,agg::path_storage * path_data,const CFX_Matrix * pObject2Device,const CFX_GraphStateData * pGraphState,float scale,bool bTextMode)242 void RasterizeStroke(agg::rasterizer_scanline_aa* rasterizer,
243                      agg::path_storage* path_data,
244                      const CFX_Matrix* pObject2Device,
245                      const CFX_GraphStateData* pGraphState,
246                      float scale,
247                      bool bTextMode) {
248   agg::line_cap_e cap;
249   switch (pGraphState->m_LineCap) {
250     case CFX_GraphStateData::LineCap::kRound:
251       cap = agg::round_cap;
252       break;
253     case CFX_GraphStateData::LineCap::kSquare:
254       cap = agg::square_cap;
255       break;
256     default:
257       cap = agg::butt_cap;
258       break;
259   }
260   agg::line_join_e join;
261   switch (pGraphState->m_LineJoin) {
262     case CFX_GraphStateData::LineJoin::kRound:
263       join = agg::round_join;
264       break;
265     case CFX_GraphStateData::LineJoin::kBevel:
266       join = agg::bevel_join;
267       break;
268     default:
269       join = agg::miter_join_revert;
270       break;
271   }
272   float width = pGraphState->m_LineWidth * scale;
273   float unit = 1.0f;
274   if (pObject2Device) {
275     unit =
276         1.0f / ((pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2);
277   }
278   width = std::max(width, unit);
279   if (!pGraphState->m_DashArray.empty()) {
280     using DashConverter = agg::conv_dash<agg::path_storage>;
281     DashConverter dash(*path_data);
282     for (size_t i = 0; i < (pGraphState->m_DashArray.size() + 1) / 2; i++) {
283       float on = pGraphState->m_DashArray[i * 2];
284       if (on <= 0.000001f)
285         on = 0.1f;
286       float off = i * 2 + 1 == pGraphState->m_DashArray.size()
287                       ? on
288                       : pGraphState->m_DashArray[i * 2 + 1];
289       off = std::max(off, 0.0f);
290       dash.add_dash(on * scale, off * scale);
291     }
292     dash.dash_start(pGraphState->m_DashPhase * scale);
293     using DashStroke = agg::conv_stroke<DashConverter>;
294     DashStroke stroke(dash);
295     stroke.line_join(join);
296     stroke.line_cap(cap);
297     stroke.miter_limit(pGraphState->m_MiterLimit);
298     stroke.width(width);
299     rasterizer->add_path_transformed(stroke, pObject2Device);
300     return;
301   }
302   agg::conv_stroke<agg::path_storage> stroke(*path_data);
303   stroke.line_join(join);
304   stroke.line_cap(cap);
305   stroke.miter_limit(pGraphState->m_MiterLimit);
306   stroke.width(width);
307   rasterizer->add_path_transformed(stroke, pObject2Device);
308 }
309 
GetAlternateOrWindingFillType(const CFX_FillRenderOptions & fill_options)310 agg::filling_rule_e GetAlternateOrWindingFillType(
311     const CFX_FillRenderOptions& fill_options) {
312   return fill_options.fill_type == CFX_FillRenderOptions::FillType::kWinding
313              ? agg::fill_non_zero
314              : agg::fill_even_odd;
315 }
316 
GetClipMaskFromRegion(const CFX_ClipRgn * r)317 RetainPtr<CFX_DIBitmap> GetClipMaskFromRegion(const CFX_ClipRgn* r) {
318   return (r && r->GetType() == CFX_ClipRgn::kMaskF) ? r->GetMask() : nullptr;
319 }
320 
GetClipBoxFromRegion(const RetainPtr<CFX_DIBitmap> & device,const CFX_ClipRgn * region)321 FX_RECT GetClipBoxFromRegion(const RetainPtr<CFX_DIBitmap>& device,
322                              const CFX_ClipRgn* region) {
323   if (region)
324     return region->GetBox();
325   return FX_RECT(0, 0, device->GetWidth(), device->GetHeight());
326 }
327 
328 class CFX_Renderer {
329  public:
330   CFX_Renderer(const RetainPtr<CFX_DIBitmap>& pDevice,
331                const RetainPtr<CFX_DIBitmap>& pBackdropDevice,
332                const CFX_ClipRgn* pClipRgn,
333                uint32_t color,
334                bool bFullCover,
335                bool bRgbByteOrder);
336 
337   // Needed for agg caller
prepare(unsigned)338   void prepare(unsigned) {}
339 
340   template <class Scanline>
341   void render(const Scanline& sl);
342 
343  private:
344   using CompositeSpanFunc = void (CFX_Renderer::*)(uint8_t*,
345                                                    int,
346                                                    int,
347                                                    int,
348                                                    const uint8_t*,
349                                                    int,
350                                                    int,
351                                                    const uint8_t*);
352 
353   void CompositeSpan(uint8_t* dest_scan,
354                      const uint8_t* backdrop_scan,
355                      int Bpp,
356                      bool bDestAlpha,
357                      int span_left,
358                      int span_len,
359                      const uint8_t* cover_scan,
360                      int clip_left,
361                      int clip_right,
362                      const uint8_t* clip_scan);
363 
364   void CompositeSpan1bpp(uint8_t* dest_scan,
365                          int Bpp,
366                          int span_left,
367                          int span_len,
368                          const uint8_t* cover_scan,
369                          int clip_left,
370                          int clip_right,
371                          const uint8_t* clip_scan);
372 
373   void CompositeSpanGray(uint8_t* dest_scan,
374                          int Bpp,
375                          int span_left,
376                          int span_len,
377                          const uint8_t* cover_scan,
378                          int clip_left,
379                          int clip_right,
380                          const uint8_t* clip_scan);
381 
382   void CompositeSpanARGB(uint8_t* dest_scan,
383                          int Bpp,
384                          int span_left,
385                          int span_len,
386                          const uint8_t* cover_scan,
387                          int clip_left,
388                          int clip_right,
389                          const uint8_t* clip_scan);
390 
391   void CompositeSpanRGB(uint8_t* dest_scan,
392                         int Bpp,
393                         int span_left,
394                         int span_len,
395                         const uint8_t* cover_scan,
396                         int clip_left,
397                         int clip_right,
398                         const uint8_t* clip_scan);
399 
400   void CompositeSpan1bppHelper(uint8_t* dest_scan,
401                                int col_start,
402                                int col_end,
403                                const uint8_t* cover_scan,
404                                const uint8_t* clip_scan,
405                                int span_left);
406 
GetCompositeSpanFunc(const RetainPtr<CFX_DIBitmap> & device)407   static CompositeSpanFunc GetCompositeSpanFunc(
408       const RetainPtr<CFX_DIBitmap>& device) {
409     if (device->GetBPP() == 1)
410       return &CFX_Renderer::CompositeSpan1bpp;
411     if (device->GetBPP() == 8)
412       return &CFX_Renderer::CompositeSpanGray;
413     if (device->GetFormat() == FXDIB_Format::kArgb)
414       return &CFX_Renderer::CompositeSpanARGB;
415     return &CFX_Renderer::CompositeSpanRGB;
416   }
417 
GetSrcAlpha(const uint8_t * clip_scan,int col) const418   inline int GetSrcAlpha(const uint8_t* clip_scan, int col) const {
419     return clip_scan ? m_Alpha * clip_scan[col] / 255 : m_Alpha;
420   }
421 
GetSourceAlpha(const uint8_t * cover_scan,const uint8_t * clip_scan,int col) const422   inline int GetSourceAlpha(const uint8_t* cover_scan,
423                             const uint8_t* clip_scan,
424                             int col) const {
425     return clip_scan ? m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255
426                      : m_Alpha * cover_scan[col] / 255;
427   }
428 
GetColStart(int span_left,int clip_left) const429   inline int GetColStart(int span_left, int clip_left) const {
430     return span_left < clip_left ? clip_left - span_left : 0;
431   }
432 
GetColEnd(int span_left,int span_len,int clip_right) const433   inline int GetColEnd(int span_left, int span_len, int clip_right) const {
434     return span_left + span_len < clip_right ? span_len
435                                              : clip_right - span_left;
436   }
437 
438   int m_Alpha;
439   int m_Red;
440   int m_Green;
441   int m_Blue;
442   int m_Gray;
443   const uint32_t m_Color;
444   const bool m_bFullCover;
445   const bool m_bRgbByteOrder;
446   const FX_RECT m_ClipBox;
447   RetainPtr<CFX_DIBitmap> const m_pBackdropDevice;
448   RetainPtr<CFX_DIBitmap> const m_pClipMask;
449   RetainPtr<CFX_DIBitmap> const m_pDevice;
450   UnownedPtr<const CFX_ClipRgn> m_pClipRgn;
451   const CompositeSpanFunc m_CompositeSpanFunc;
452 };
453 
CompositeSpan(uint8_t * dest_scan,const uint8_t * backdrop_scan,int Bpp,bool bDestAlpha,int span_left,int span_len,const uint8_t * cover_scan,int clip_left,int clip_right,const uint8_t * clip_scan)454 void CFX_Renderer::CompositeSpan(uint8_t* dest_scan,
455                                  const uint8_t* backdrop_scan,
456                                  int Bpp,
457                                  bool bDestAlpha,
458                                  int span_left,
459                                  int span_len,
460                                  const uint8_t* cover_scan,
461                                  int clip_left,
462                                  int clip_right,
463                                  const uint8_t* clip_scan) {
464   int col_start = GetColStart(span_left, clip_left);
465   int col_end = GetColEnd(span_left, span_len, clip_right);
466   if (Bpp) {
467     dest_scan += col_start * Bpp;
468     backdrop_scan += col_start * Bpp;
469   } else {
470     dest_scan += col_start / 8;
471     backdrop_scan += col_start / 8;
472   }
473   if (m_bRgbByteOrder) {
474     if (Bpp == 4 && bDestAlpha) {
475       for (int col = col_start; col < col_end; col++) {
476         int src_alpha = GetSrcAlpha(clip_scan, col);
477         uint8_t dest_alpha =
478             backdrop_scan[3] + src_alpha - backdrop_scan[3] * src_alpha / 255;
479         dest_scan[3] = dest_alpha;
480         int alpha_ratio = src_alpha * 255 / dest_alpha;
481         if (m_bFullCover) {
482           *dest_scan++ =
483               FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Red, alpha_ratio);
484           *dest_scan++ =
485               FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Green, alpha_ratio);
486           *dest_scan++ =
487               FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Blue, alpha_ratio);
488           dest_scan++;
489           backdrop_scan++;
490         } else {
491           int r = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Red, alpha_ratio);
492           int g = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Green, alpha_ratio);
493           int b = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Blue, alpha_ratio);
494           backdrop_scan++;
495           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]);
496           dest_scan++;
497           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
498           dest_scan++;
499           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]);
500           dest_scan += 2;
501         }
502       }
503       return;
504     }
505     if (Bpp == 3 || Bpp == 4) {
506       for (int col = col_start; col < col_end; col++) {
507         int src_alpha = GetSrcAlpha(clip_scan, col);
508         int r = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Red, src_alpha);
509         int g = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Green, src_alpha);
510         int b = FXDIB_ALPHA_MERGE(*backdrop_scan, m_Blue, src_alpha);
511         backdrop_scan += Bpp - 2;
512         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]);
513         dest_scan++;
514         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
515         dest_scan++;
516         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]);
517         dest_scan += Bpp - 2;
518       }
519     }
520     return;
521   }
522   if (Bpp == 4 && bDestAlpha) {
523     for (int col = col_start; col < col_end; col++) {
524       int src_alpha = GetSrcAlpha(clip_scan, col);
525       int src_alpha_covered = src_alpha * cover_scan[col] / 255;
526       if (src_alpha_covered == 0) {
527         dest_scan += 4;
528         continue;
529       }
530       if (cover_scan[col] == 255) {
531         dest_scan[3] = src_alpha_covered;
532         *dest_scan++ = m_Blue;
533         *dest_scan++ = m_Green;
534         *dest_scan = m_Red;
535         dest_scan += 2;
536         continue;
537       }
538       if (dest_scan[3] == 0) {
539         dest_scan[3] = src_alpha_covered;
540         *dest_scan++ = m_Blue;
541         *dest_scan++ = m_Green;
542         *dest_scan = m_Red;
543         dest_scan += 2;
544         continue;
545       }
546       uint8_t cover = cover_scan[col];
547       dest_scan[3] = FXDIB_ALPHA_MERGE(dest_scan[3], src_alpha, cover);
548       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, cover);
549       dest_scan++;
550       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, cover);
551       dest_scan++;
552       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, cover);
553       dest_scan += 2;
554     }
555     return;
556   }
557   if (Bpp == 3 || Bpp == 4) {
558     for (int col = col_start; col < col_end; col++) {
559       int src_alpha = GetSrcAlpha(clip_scan, col);
560       if (m_bFullCover) {
561         *dest_scan++ = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Blue, src_alpha);
562         *dest_scan++ = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Green, src_alpha);
563         *dest_scan = FXDIB_ALPHA_MERGE(*backdrop_scan, m_Red, src_alpha);
564         dest_scan += Bpp - 2;
565         backdrop_scan += Bpp - 2;
566         continue;
567       }
568       int b = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Blue, src_alpha);
569       int g = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Green, src_alpha);
570       int r = FXDIB_ALPHA_MERGE(*backdrop_scan, m_Red, src_alpha);
571       backdrop_scan += Bpp - 2;
572       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, b, cover_scan[col]);
573       dest_scan++;
574       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, g, cover_scan[col]);
575       dest_scan++;
576       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, r, cover_scan[col]);
577       dest_scan += Bpp - 2;
578     }
579     return;
580   }
581   if (Bpp == 1) {
582     for (int col = col_start; col < col_end; col++) {
583       int src_alpha = GetSrcAlpha(clip_scan, col);
584       if (m_bFullCover) {
585         *dest_scan = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Gray, src_alpha);
586         continue;
587       }
588       int gray = FXDIB_ALPHA_MERGE(*backdrop_scan++, m_Gray, src_alpha);
589       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan[col]);
590       dest_scan++;
591     }
592     return;
593   }
594   CompositeSpan1bppHelper(dest_scan, col_start, col_end, cover_scan, clip_scan,
595                           span_left);
596 }
597 
CompositeSpan1bpp(uint8_t * dest_scan,int Bpp,int span_left,int span_len,const uint8_t * cover_scan,int clip_left,int clip_right,const uint8_t * clip_scan)598 void CFX_Renderer::CompositeSpan1bpp(uint8_t* dest_scan,
599                                      int Bpp,
600                                      int span_left,
601                                      int span_len,
602                                      const uint8_t* cover_scan,
603                                      int clip_left,
604                                      int clip_right,
605                                      const uint8_t* clip_scan) {
606   DCHECK(!m_bRgbByteOrder);
607   int col_start = GetColStart(span_left, clip_left);
608   int col_end = GetColEnd(span_left, span_len, clip_right);
609   dest_scan += col_start / 8;
610   CompositeSpan1bppHelper(dest_scan, col_start, col_end, cover_scan, clip_scan,
611                           span_left);
612 }
613 
CompositeSpanGray(uint8_t * dest_scan,int Bpp,int span_left,int span_len,const uint8_t * cover_scan,int clip_left,int clip_right,const uint8_t * clip_scan)614 void CFX_Renderer::CompositeSpanGray(uint8_t* dest_scan,
615                                      int Bpp,
616                                      int span_left,
617                                      int span_len,
618                                      const uint8_t* cover_scan,
619                                      int clip_left,
620                                      int clip_right,
621                                      const uint8_t* clip_scan) {
622   DCHECK(!m_bRgbByteOrder);
623   int col_start = GetColStart(span_left, clip_left);
624   int col_end = GetColEnd(span_left, span_len, clip_right);
625   dest_scan += col_start;
626   for (int col = col_start; col < col_end; col++) {
627     int src_alpha = GetSourceAlpha(cover_scan, clip_scan, col);
628     if (src_alpha) {
629       if (src_alpha == 255)
630         *dest_scan = m_Gray;
631       else
632         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
633     }
634     dest_scan++;
635   }
636 }
637 
CompositeSpanARGB(uint8_t * dest_scan,int Bpp,int span_left,int span_len,const uint8_t * cover_scan,int clip_left,int clip_right,const uint8_t * clip_scan)638 void CFX_Renderer::CompositeSpanARGB(uint8_t* dest_scan,
639                                      int Bpp,
640                                      int span_left,
641                                      int span_len,
642                                      const uint8_t* cover_scan,
643                                      int clip_left,
644                                      int clip_right,
645                                      const uint8_t* clip_scan) {
646   int col_start = GetColStart(span_left, clip_left);
647   int col_end = GetColEnd(span_left, span_len, clip_right);
648   dest_scan += col_start * Bpp;
649   if (m_bRgbByteOrder) {
650     for (int col = col_start; col < col_end; col++) {
651       int src_alpha = m_bFullCover ? GetSrcAlpha(clip_scan, col)
652                                    : GetSourceAlpha(cover_scan, clip_scan, col);
653       if (src_alpha) {
654         if (src_alpha == 255) {
655           *(reinterpret_cast<uint32_t*>(dest_scan)) = m_Color;
656         } else {
657           uint8_t dest_alpha =
658               dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
659           dest_scan[3] = dest_alpha;
660           int alpha_ratio = src_alpha * 255 / dest_alpha;
661           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
662           dest_scan++;
663           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
664           dest_scan++;
665           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
666           dest_scan += 2;
667           continue;
668         }
669       }
670       dest_scan += 4;
671     }
672     return;
673   }
674   for (int col = col_start; col < col_end; col++) {
675     int src_alpha = m_bFullCover ? GetSrcAlpha(clip_scan, col)
676                                  : GetSourceAlpha(cover_scan, clip_scan, col);
677     if (src_alpha) {
678       if (src_alpha == 255) {
679         *(reinterpret_cast<uint32_t*>(dest_scan)) = m_Color;
680       } else {
681         if (dest_scan[3] == 0) {
682           dest_scan[3] = src_alpha;
683           *dest_scan++ = m_Blue;
684           *dest_scan++ = m_Green;
685           *dest_scan = m_Red;
686           dest_scan += 2;
687           continue;
688         }
689         uint8_t dest_alpha =
690             dest_scan[3] + src_alpha - dest_scan[3] * src_alpha / 255;
691         dest_scan[3] = dest_alpha;
692         int alpha_ratio = src_alpha * 255 / dest_alpha;
693         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, alpha_ratio);
694         dest_scan++;
695         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
696         dest_scan++;
697         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
698         dest_scan += 2;
699         continue;
700       }
701     }
702     dest_scan += Bpp;
703   }
704 }
705 
CompositeSpanRGB(uint8_t * dest_scan,int Bpp,int span_left,int span_len,const uint8_t * cover_scan,int clip_left,int clip_right,const uint8_t * clip_scan)706 void CFX_Renderer::CompositeSpanRGB(uint8_t* dest_scan,
707                                     int Bpp,
708                                     int span_left,
709                                     int span_len,
710                                     const uint8_t* cover_scan,
711                                     int clip_left,
712                                     int clip_right,
713                                     const uint8_t* clip_scan) {
714   int col_start = GetColStart(span_left, clip_left);
715   int col_end = GetColEnd(span_left, span_len, clip_right);
716   dest_scan += col_start * Bpp;
717   if (m_bRgbByteOrder) {
718     for (int col = col_start; col < col_end; col++) {
719       int src_alpha = GetSourceAlpha(cover_scan, clip_scan, col);
720       if (src_alpha) {
721         if (src_alpha == 255) {
722           if (Bpp == 4) {
723             *(uint32_t*)dest_scan = m_Color;
724           } else if (Bpp == 3) {
725             *dest_scan++ = m_Red;
726             *dest_scan++ = m_Green;
727             *dest_scan++ = m_Blue;
728             continue;
729           }
730         } else {
731           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
732           dest_scan++;
733           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
734           dest_scan++;
735           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
736           dest_scan += Bpp - 2;
737           continue;
738         }
739       }
740       dest_scan += Bpp;
741     }
742     return;
743   }
744   for (int col = col_start; col < col_end; col++) {
745     int src_alpha = m_bFullCover ? GetSrcAlpha(clip_scan, col)
746                                  : GetSourceAlpha(cover_scan, clip_scan, col);
747     if (src_alpha) {
748       if (src_alpha == 255) {
749         if (Bpp == 4) {
750           *(uint32_t*)dest_scan = m_Color;
751         } else if (Bpp == 3) {
752           *dest_scan++ = m_Blue;
753           *dest_scan++ = m_Green;
754           *dest_scan++ = m_Red;
755           continue;
756         }
757       } else {
758         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Blue, src_alpha);
759         dest_scan++;
760         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, src_alpha);
761         dest_scan++;
762         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
763         dest_scan += Bpp - 2;
764         continue;
765       }
766     }
767     dest_scan += Bpp;
768   }
769 }
770 
CFX_Renderer(const RetainPtr<CFX_DIBitmap> & pDevice,const RetainPtr<CFX_DIBitmap> & pBackdropDevice,const CFX_ClipRgn * pClipRgn,uint32_t color,bool bFullCover,bool bRgbByteOrder)771 CFX_Renderer::CFX_Renderer(const RetainPtr<CFX_DIBitmap>& pDevice,
772                            const RetainPtr<CFX_DIBitmap>& pBackdropDevice,
773                            const CFX_ClipRgn* pClipRgn,
774                            uint32_t color,
775                            bool bFullCover,
776                            bool bRgbByteOrder)
777     : m_Alpha(FXARGB_A(color)),
778       m_Color(bRgbByteOrder ? FXARGB_TOBGRORDERDIB(color) : color),
779       m_bFullCover(bFullCover),
780       m_bRgbByteOrder(bRgbByteOrder),
781       m_ClipBox(GetClipBoxFromRegion(pDevice, pClipRgn)),
782       m_pBackdropDevice(pBackdropDevice),
783       m_pClipMask(GetClipMaskFromRegion(pClipRgn)),
784       m_pDevice(pDevice),
785       m_pClipRgn(pClipRgn),
786       m_CompositeSpanFunc(GetCompositeSpanFunc(m_pDevice)) {
787   if (m_pDevice->GetBPP() == 8) {
788     DCHECK(!m_bRgbByteOrder);
789     if (m_pDevice->IsMaskFormat())
790       m_Gray = 255;
791     else
792       m_Gray = FXRGB2GRAY(FXARGB_R(color), FXARGB_G(color), FXARGB_B(color));
793     return;
794   }
795 
796   std::tie(m_Alpha, m_Red, m_Green, m_Blue) = ArgbDecode(color);
797 }
798 
799 template <class Scanline>
render(const Scanline & sl)800 void CFX_Renderer::render(const Scanline& sl) {
801   int y = sl.y();
802   if (y < m_ClipBox.top || y >= m_ClipBox.bottom)
803     return;
804 
805   uint8_t* dest_scan =
806       m_pDevice->GetWritableBuffer().subspan(m_pDevice->GetPitch() * y).data();
807   const uint8_t* backdrop_scan = nullptr;
808   if (m_pBackdropDevice) {
809     backdrop_scan = m_pBackdropDevice->GetBuffer()
810                         .subspan(m_pBackdropDevice->GetPitch() * y)
811                         .data();
812   }
813   int Bpp = m_pDevice->GetBPP() / 8;
814   bool bDestAlpha = m_pDevice->IsAlphaFormat() || m_pDevice->IsMaskFormat();
815   unsigned num_spans = sl.num_spans();
816   typename Scanline::const_iterator span = sl.begin();
817   while (true) {
818     if (span->len <= 0)
819       break;
820 
821     int x = span->x;
822     uint8_t* dest_pos = nullptr;
823     const uint8_t* backdrop_pos = nullptr;
824     if (Bpp) {
825       backdrop_pos = backdrop_scan ? backdrop_scan + x * Bpp : nullptr;
826       dest_pos = dest_scan + x * Bpp;
827     } else {
828       dest_pos = dest_scan + x / 8;
829       backdrop_pos = backdrop_scan ? backdrop_scan + x / 8 : nullptr;
830     }
831     const uint8_t* clip_pos = nullptr;
832     if (m_pClipMask) {
833       // TODO(crbug.com/1382604): use subspan arithmetic.
834       clip_pos = m_pClipMask->GetBuffer().data() +
835                  (y - m_ClipBox.top) * m_pClipMask->GetPitch() + x -
836                  m_ClipBox.left;
837     }
838     if (backdrop_pos) {
839       CompositeSpan(dest_pos, backdrop_pos, Bpp, bDestAlpha, x, span->len,
840                     span->covers, m_ClipBox.left, m_ClipBox.right, clip_pos);
841     } else {
842       (this->*m_CompositeSpanFunc)(dest_pos, Bpp, x, span->len, span->covers,
843                                    m_ClipBox.left, m_ClipBox.right, clip_pos);
844     }
845     if (--num_spans == 0)
846       break;
847 
848     ++span;
849   }
850 }
851 
CompositeSpan1bppHelper(uint8_t * dest_scan,int col_start,int col_end,const uint8_t * cover_scan,const uint8_t * clip_scan,int span_left)852 void CFX_Renderer::CompositeSpan1bppHelper(uint8_t* dest_scan,
853                                            int col_start,
854                                            int col_end,
855                                            const uint8_t* cover_scan,
856                                            const uint8_t* clip_scan,
857                                            int span_left) {
858   int index = 0;
859   if (m_pDevice->HasPalette()) {
860     for (int i = 0; i < 2; i++) {
861       if (m_pDevice->GetPaletteSpan()[i] == m_Color)
862         index = i;
863     }
864   } else {
865     index = (static_cast<uint8_t>(m_Color) == 0xff) ? 1 : 0;
866   }
867   uint8_t* dest_scan1 = dest_scan;
868   for (int col = col_start; col < col_end; col++) {
869     int src_alpha = GetSourceAlpha(cover_scan, clip_scan, col);
870     if (src_alpha) {
871       if (!index)
872         *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
873       else
874         *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
875     }
876     dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
877   }
878 }
879 
880 template <class BaseRenderer>
881 class RendererScanLineAaOffset {
882  public:
883   typedef BaseRenderer base_ren_type;
884   typedef typename base_ren_type::color_type color_type;
RendererScanLineAaOffset(base_ren_type & ren,unsigned left,unsigned top)885   RendererScanLineAaOffset(base_ren_type& ren, unsigned left, unsigned top)
886       : m_ren(&ren), m_left(left), m_top(top) {}
color(const color_type & c)887   void color(const color_type& c) { m_color = c; }
color() const888   const color_type& color() const { return m_color; }
prepare(unsigned)889   void prepare(unsigned) {}
890   template <class Scanline>
render(const Scanline & sl)891   void render(const Scanline& sl) {
892     int y = sl.y();
893     unsigned num_spans = sl.num_spans();
894     typename Scanline::const_iterator span = sl.begin();
895     while (true) {
896       int x = span->x;
897       if (span->len > 0) {
898         m_ren->blend_solid_hspan(x - m_left, y - m_top, (unsigned)span->len,
899                                  m_color, span->covers);
900       } else {
901         m_ren->blend_hline(x - m_left, y - m_top, (unsigned)(x - span->len - 1),
902                            m_color, *(span->covers));
903       }
904       if (--num_spans == 0)
905         break;
906 
907       ++span;
908     }
909   }
910 
911  private:
912   UNOWNED_PTR_EXCLUSION base_ren_type* m_ren;
913   color_type m_color;
914   unsigned m_left;
915   unsigned m_top;
916 };
917 
BuildAggPath(const CFX_Path & path,const CFX_Matrix * pObject2Device)918 agg::path_storage BuildAggPath(const CFX_Path& path,
919                                const CFX_Matrix* pObject2Device) {
920   agg::path_storage agg_path;
921   pdfium::span<const CFX_Path::Point> points = path.GetPoints();
922   for (size_t i = 0; i < points.size(); ++i) {
923     CFX_PointF pos = points[i].m_Point;
924     if (pObject2Device)
925       pos = pObject2Device->Transform(pos);
926 
927     pos = HardClip(pos);
928     CFX_Path::Point::Type point_type = points[i].m_Type;
929     if (point_type == CFX_Path::Point::Type::kMove) {
930       agg_path.move_to(pos.x, pos.y);
931     } else if (point_type == CFX_Path::Point::Type::kLine) {
932       if (i > 0 && points[i - 1].IsTypeAndOpen(CFX_Path::Point::Type::kMove) &&
933           (i == points.size() - 1 ||
934            points[i + 1].IsTypeAndOpen(CFX_Path::Point::Type::kMove)) &&
935           points[i].m_Point == points[i - 1].m_Point) {
936         pos.x += 1;
937       }
938       agg_path.line_to(pos.x, pos.y);
939     } else if (point_type == CFX_Path::Point::Type::kBezier) {
940       if (i > 0 && i + 2 < points.size()) {
941         CFX_PointF pos0 = points[i - 1].m_Point;
942         CFX_PointF pos2 = points[i + 1].m_Point;
943         CFX_PointF pos3 = points[i + 2].m_Point;
944         if (pObject2Device) {
945           pos0 = pObject2Device->Transform(pos0);
946           pos2 = pObject2Device->Transform(pos2);
947           pos3 = pObject2Device->Transform(pos3);
948         }
949         pos0 = HardClip(pos0);
950         pos2 = HardClip(pos2);
951         pos3 = HardClip(pos3);
952         agg::curve4 curve(pos0.x, pos0.y, pos.x, pos.y, pos2.x, pos2.y, pos3.x,
953                           pos3.y);
954         i += 2;
955         agg_path.add_path(curve);
956       }
957     }
958     if (points[i].m_CloseFigure)
959       agg_path.end_poly();
960   }
961   return agg_path;
962 }
963 
964 }  // namespace
965 
CFX_AggDeviceDriver(RetainPtr<CFX_DIBitmap> pBitmap,bool bRgbByteOrder,RetainPtr<CFX_DIBitmap> pBackdropBitmap,bool bGroupKnockout)966 CFX_AggDeviceDriver::CFX_AggDeviceDriver(
967     RetainPtr<CFX_DIBitmap> pBitmap,
968     bool bRgbByteOrder,
969     RetainPtr<CFX_DIBitmap> pBackdropBitmap,
970     bool bGroupKnockout)
971     : m_pBitmap(std::move(pBitmap)),
972       m_bRgbByteOrder(bRgbByteOrder),
973       m_bGroupKnockout(bGroupKnockout),
974       m_pBackdropBitmap(std::move(pBackdropBitmap)) {
975   DCHECK(m_pBitmap);
976   DCHECK_NE(m_pBitmap->GetFormat(), FXDIB_Format::k1bppMask);
977   DCHECK_NE(m_pBitmap->GetFormat(), FXDIB_Format::k1bppRgb);
978   InitPlatform();
979 }
980 
~CFX_AggDeviceDriver()981 CFX_AggDeviceDriver::~CFX_AggDeviceDriver() {
982   DestroyPlatform();
983 }
984 
985 #if !BUILDFLAG(IS_APPLE)
InitPlatform()986 void CFX_AggDeviceDriver::InitPlatform() {}
987 
DestroyPlatform()988 void CFX_AggDeviceDriver::DestroyPlatform() {}
989 
DrawDeviceText(pdfium::span<const TextCharPos> pCharPos,CFX_Font * pFont,const CFX_Matrix & mtObject2Device,float font_size,uint32_t color,const CFX_TextRenderOptions & options)990 bool CFX_AggDeviceDriver::DrawDeviceText(
991     pdfium::span<const TextCharPos> pCharPos,
992     CFX_Font* pFont,
993     const CFX_Matrix& mtObject2Device,
994     float font_size,
995     uint32_t color,
996     const CFX_TextRenderOptions& options) {
997   return false;
998 }
999 #endif  // !BUILDFLAG(IS_APPLE)
1000 
GetDeviceType() const1001 DeviceType CFX_AggDeviceDriver::GetDeviceType() const {
1002   return DeviceType::kDisplay;
1003 }
1004 
GetDeviceCaps(int caps_id) const1005 int CFX_AggDeviceDriver::GetDeviceCaps(int caps_id) const {
1006   switch (caps_id) {
1007     case FXDC_PIXEL_WIDTH:
1008       return m_pBitmap->GetWidth();
1009     case FXDC_PIXEL_HEIGHT:
1010       return m_pBitmap->GetHeight();
1011     case FXDC_BITS_PIXEL:
1012       return m_pBitmap->GetBPP();
1013     case FXDC_HORZ_SIZE:
1014     case FXDC_VERT_SIZE:
1015       return 0;
1016     case FXDC_RENDER_CAPS: {
1017       int flags = FXRC_GET_BITS | FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE |
1018                   FXRC_BLEND_MODE | FXRC_SOFT_CLIP;
1019       if (m_pBitmap->IsAlphaFormat()) {
1020         flags |= FXRC_ALPHA_OUTPUT;
1021       } else if (m_pBitmap->IsMaskFormat()) {
1022         if (m_pBitmap->GetBPP() == 1)
1023           flags |= FXRC_BITMASK_OUTPUT;
1024         else
1025           flags |= FXRC_BYTEMASK_OUTPUT;
1026       }
1027       return flags;
1028     }
1029     default:
1030       NOTREACHED_NORETURN();
1031   }
1032 }
1033 
SaveState()1034 void CFX_AggDeviceDriver::SaveState() {
1035   std::unique_ptr<CFX_ClipRgn> pClip;
1036   if (m_pClipRgn)
1037     pClip = std::make_unique<CFX_ClipRgn>(*m_pClipRgn);
1038   m_StateStack.push_back(std::move(pClip));
1039 }
1040 
RestoreState(bool bKeepSaved)1041 void CFX_AggDeviceDriver::RestoreState(bool bKeepSaved) {
1042   m_pClipRgn.reset();
1043 
1044   if (m_StateStack.empty())
1045     return;
1046 
1047   if (bKeepSaved) {
1048     if (m_StateStack.back())
1049       m_pClipRgn = std::make_unique<CFX_ClipRgn>(*m_StateStack.back());
1050   } else {
1051     m_pClipRgn = std::move(m_StateStack.back());
1052     m_StateStack.pop_back();
1053   }
1054 }
1055 
SetClipMask(agg::rasterizer_scanline_aa & rasterizer)1056 void CFX_AggDeviceDriver::SetClipMask(agg::rasterizer_scanline_aa& rasterizer) {
1057   FX_RECT path_rect(rasterizer.min_x(), rasterizer.min_y(),
1058                     rasterizer.max_x() + 1, rasterizer.max_y() + 1);
1059   path_rect.Intersect(m_pClipRgn->GetBox());
1060   auto pThisLayer = pdfium::MakeRetain<CFX_DIBitmap>();
1061   pThisLayer->Create(path_rect.Width(), path_rect.Height(),
1062                      FXDIB_Format::k8bppMask);
1063   agg::rendering_buffer raw_buf(pThisLayer->GetWritableBuffer().data(),
1064                                 pThisLayer->GetWidth(), pThisLayer->GetHeight(),
1065                                 pThisLayer->GetPitch());
1066   agg::pixfmt_gray8 pixel_buf(raw_buf);
1067   agg::renderer_base<agg::pixfmt_gray8> base_buf(pixel_buf);
1068   RendererScanLineAaOffset<agg::renderer_base<agg::pixfmt_gray8>> final_render(
1069       base_buf, path_rect.left, path_rect.top);
1070   final_render.color(agg::gray8(255));
1071   agg::scanline_u8 scanline;
1072   agg::render_scanlines(rasterizer, scanline, final_render,
1073                         m_FillOptions.aliased_path);
1074   m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top,
1075                              std::move(pThisLayer));
1076 }
1077 
SetClip_PathFill(const CFX_Path & path,const CFX_Matrix * pObject2Device,const CFX_FillRenderOptions & fill_options)1078 bool CFX_AggDeviceDriver::SetClip_PathFill(
1079     const CFX_Path& path,
1080     const CFX_Matrix* pObject2Device,
1081     const CFX_FillRenderOptions& fill_options) {
1082   DCHECK(fill_options.fill_type != CFX_FillRenderOptions::FillType::kNoFill);
1083 
1084   m_FillOptions = fill_options;
1085   if (!m_pClipRgn) {
1086     m_pClipRgn = std::make_unique<CFX_ClipRgn>(
1087         GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
1088   }
1089   absl::optional<CFX_FloatRect> maybe_rectf = path.GetRect(pObject2Device);
1090   if (maybe_rectf.has_value()) {
1091     CFX_FloatRect& rectf = maybe_rectf.value();
1092     rectf.Intersect(
1093         CFX_FloatRect(0, 0, static_cast<float>(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
1094                       static_cast<float>(GetDeviceCaps(FXDC_PIXEL_HEIGHT))));
1095     FX_RECT rect = rectf.GetOuterRect();
1096     m_pClipRgn->IntersectRect(rect);
1097     return true;
1098   }
1099   agg::path_storage path_data = BuildAggPath(path, pObject2Device);
1100   path_data.end_poly();
1101   agg::rasterizer_scanline_aa rasterizer;
1102   rasterizer.clip_box(0.0f, 0.0f,
1103                       static_cast<float>(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
1104                       static_cast<float>(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
1105   rasterizer.add_path(path_data);
1106   rasterizer.filling_rule(GetAlternateOrWindingFillType(fill_options));
1107   SetClipMask(rasterizer);
1108   return true;
1109 }
1110 
SetClip_PathStroke(const CFX_Path & path,const CFX_Matrix * pObject2Device,const CFX_GraphStateData * pGraphState)1111 bool CFX_AggDeviceDriver::SetClip_PathStroke(
1112     const CFX_Path& path,
1113     const CFX_Matrix* pObject2Device,
1114     const CFX_GraphStateData* pGraphState) {
1115   if (!m_pClipRgn) {
1116     m_pClipRgn = std::make_unique<CFX_ClipRgn>(
1117         GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
1118   }
1119   agg::path_storage path_data = BuildAggPath(path, nullptr);
1120   agg::rasterizer_scanline_aa rasterizer;
1121   rasterizer.clip_box(0.0f, 0.0f,
1122                       static_cast<float>(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
1123                       static_cast<float>(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
1124   RasterizeStroke(&rasterizer, &path_data, pObject2Device, pGraphState, 1.0f,
1125                   false);
1126   rasterizer.filling_rule(agg::fill_non_zero);
1127   SetClipMask(rasterizer);
1128   return true;
1129 }
1130 
GetDriverType() const1131 int CFX_AggDeviceDriver::GetDriverType() const {
1132   return 1;
1133 }
1134 
MultiplyAlpha(float alpha)1135 bool CFX_AggDeviceDriver::MultiplyAlpha(float alpha) {
1136   return m_pBitmap->MultiplyAlpha(static_cast<int32_t>(alpha * 255));
1137 }
1138 
MultiplyAlpha(const RetainPtr<CFX_DIBBase> & mask)1139 bool CFX_AggDeviceDriver::MultiplyAlpha(const RetainPtr<CFX_DIBBase>& mask) {
1140   return m_pBitmap->MultiplyAlpha(mask);
1141 }
1142 
RenderRasterizer(agg::rasterizer_scanline_aa & rasterizer,uint32_t color,bool bFullCover,bool bGroupKnockout)1143 void CFX_AggDeviceDriver::RenderRasterizer(
1144     agg::rasterizer_scanline_aa& rasterizer,
1145     uint32_t color,
1146     bool bFullCover,
1147     bool bGroupKnockout) {
1148   RetainPtr<CFX_DIBitmap> pt = bGroupKnockout ? m_pBackdropBitmap : nullptr;
1149   CFX_Renderer render(m_pBitmap, pt, m_pClipRgn.get(), color, bFullCover,
1150                       m_bRgbByteOrder);
1151   agg::scanline_u8 scanline;
1152   agg::render_scanlines(rasterizer, scanline, render,
1153                         m_FillOptions.aliased_path);
1154 }
1155 
DrawPath(const CFX_Path & path,const CFX_Matrix * pObject2Device,const CFX_GraphStateData * pGraphState,uint32_t fill_color,uint32_t stroke_color,const CFX_FillRenderOptions & fill_options,BlendMode blend_type)1156 bool CFX_AggDeviceDriver::DrawPath(const CFX_Path& path,
1157                                    const CFX_Matrix* pObject2Device,
1158                                    const CFX_GraphStateData* pGraphState,
1159                                    uint32_t fill_color,
1160                                    uint32_t stroke_color,
1161                                    const CFX_FillRenderOptions& fill_options,
1162                                    BlendMode blend_type) {
1163   if (blend_type != BlendMode::kNormal)
1164     return false;
1165 
1166   if (m_pBitmap->GetBuffer().empty())
1167     return true;
1168 
1169   m_FillOptions = fill_options;
1170   if (fill_options.fill_type != CFX_FillRenderOptions::FillType::kNoFill &&
1171       fill_color) {
1172     agg::path_storage path_data = BuildAggPath(path, pObject2Device);
1173     agg::rasterizer_scanline_aa rasterizer;
1174     rasterizer.clip_box(0.0f, 0.0f,
1175                         static_cast<float>(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
1176                         static_cast<float>(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
1177     rasterizer.add_path(path_data);
1178     rasterizer.filling_rule(GetAlternateOrWindingFillType(fill_options));
1179     RenderRasterizer(rasterizer, fill_color, fill_options.full_cover,
1180                      /*bGroupKnockout=*/false);
1181   }
1182   int stroke_alpha = FXARGB_A(stroke_color);
1183   if (!pGraphState || !stroke_alpha)
1184     return true;
1185 
1186   if (fill_options.zero_area) {
1187     agg::path_storage path_data = BuildAggPath(path, pObject2Device);
1188     agg::rasterizer_scanline_aa rasterizer;
1189     rasterizer.clip_box(0.0f, 0.0f,
1190                         static_cast<float>(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
1191                         static_cast<float>(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
1192     RasterizeStroke(&rasterizer, &path_data, nullptr, pGraphState, 1,
1193                     fill_options.stroke_text_mode);
1194     RenderRasterizer(rasterizer, stroke_color, fill_options.full_cover,
1195                      m_bGroupKnockout);
1196     return true;
1197   }
1198   CFX_Matrix matrix1;
1199   CFX_Matrix matrix2;
1200   if (pObject2Device) {
1201     matrix1.a = std::max(fabs(pObject2Device->a), fabs(pObject2Device->b));
1202     matrix1.d = matrix1.a;
1203     matrix2 = CFX_Matrix(
1204         pObject2Device->a / matrix1.a, pObject2Device->b / matrix1.a,
1205         pObject2Device->c / matrix1.d, pObject2Device->d / matrix1.d, 0, 0);
1206 
1207     matrix1 = *pObject2Device * matrix2.GetInverse();
1208   }
1209 
1210   agg::path_storage path_data = BuildAggPath(path, &matrix1);
1211   agg::rasterizer_scanline_aa rasterizer;
1212   rasterizer.clip_box(0.0f, 0.0f,
1213                       static_cast<float>(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
1214                       static_cast<float>(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
1215   RasterizeStroke(&rasterizer, &path_data, &matrix2, pGraphState, matrix1.a,
1216                   fill_options.stroke_text_mode);
1217   RenderRasterizer(rasterizer, stroke_color, fill_options.full_cover,
1218                    m_bGroupKnockout);
1219   return true;
1220 }
1221 
FillRectWithBlend(const FX_RECT & rect,uint32_t fill_color,BlendMode blend_type)1222 bool CFX_AggDeviceDriver::FillRectWithBlend(const FX_RECT& rect,
1223                                             uint32_t fill_color,
1224                                             BlendMode blend_type) {
1225   if (blend_type != BlendMode::kNormal)
1226     return false;
1227 
1228   if (m_pBitmap->GetBuffer().empty())
1229     return true;
1230 
1231   FX_RECT clip_rect;
1232   GetClipBox(&clip_rect);
1233   FX_RECT draw_rect = clip_rect;
1234   draw_rect.Intersect(rect);
1235   if (draw_rect.IsEmpty())
1236     return true;
1237 
1238   if (!m_pClipRgn || m_pClipRgn->GetType() == CFX_ClipRgn::kRectI) {
1239     if (m_bRgbByteOrder) {
1240       RgbByteOrderCompositeRect(m_pBitmap, draw_rect.left, draw_rect.top,
1241                                 draw_rect.Width(), draw_rect.Height(),
1242                                 fill_color);
1243     } else {
1244       m_pBitmap->CompositeRect(draw_rect.left, draw_rect.top, draw_rect.Width(),
1245                                draw_rect.Height(), fill_color);
1246     }
1247     return true;
1248   }
1249   m_pBitmap->CompositeMask(draw_rect.left, draw_rect.top, draw_rect.Width(),
1250                            draw_rect.Height(), m_pClipRgn->GetMask(),
1251                            fill_color, draw_rect.left - clip_rect.left,
1252                            draw_rect.top - clip_rect.top, BlendMode::kNormal,
1253                            nullptr, m_bRgbByteOrder);
1254   return true;
1255 }
1256 
GetClipBox(FX_RECT * pRect)1257 bool CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect) {
1258   if (!m_pClipRgn) {
1259     pRect->left = pRect->top = 0;
1260     pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH);
1261     pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT);
1262     return true;
1263   }
1264   *pRect = m_pClipRgn->GetBox();
1265   return true;
1266 }
1267 
GetDIBits(const RetainPtr<CFX_DIBitmap> & pBitmap,int left,int top)1268 bool CFX_AggDeviceDriver::GetDIBits(const RetainPtr<CFX_DIBitmap>& pBitmap,
1269                                     int left,
1270                                     int top) {
1271   if (m_pBitmap->GetBuffer().empty())
1272     return true;
1273 
1274   FX_RECT rect(left, top, left + pBitmap->GetWidth(),
1275                top + pBitmap->GetHeight());
1276   RetainPtr<CFX_DIBitmap> pBack;
1277   if (m_pBackdropBitmap) {
1278     pBack = m_pBackdropBitmap->ClipTo(rect);
1279     if (!pBack)
1280       return true;
1281 
1282     pBack->CompositeBitmap(0, 0, pBack->GetWidth(), pBack->GetHeight(),
1283                            m_pBitmap, 0, 0, BlendMode::kNormal, nullptr, false);
1284   } else {
1285     pBack = m_pBitmap->ClipTo(rect);
1286     if (!pBack)
1287       return true;
1288   }
1289 
1290   left = std::min(left, 0);
1291   top = std::min(top, 0);
1292   if (m_bRgbByteOrder) {
1293     RgbByteOrderTransferBitmap(pBitmap, rect.Width(), rect.Height(), pBack,
1294                                left, top);
1295     return true;
1296   }
1297   return pBitmap->TransferBitmap(0, 0, rect.Width(), rect.Height(), pBack, left,
1298                                  top);
1299 }
1300 
GetBackDrop()1301 RetainPtr<CFX_DIBitmap> CFX_AggDeviceDriver::GetBackDrop() {
1302   return m_pBackdropBitmap;
1303 }
1304 
SetDIBits(const RetainPtr<CFX_DIBBase> & pBitmap,uint32_t argb,const FX_RECT & src_rect,int left,int top,BlendMode blend_type)1305 bool CFX_AggDeviceDriver::SetDIBits(const RetainPtr<CFX_DIBBase>& pBitmap,
1306                                     uint32_t argb,
1307                                     const FX_RECT& src_rect,
1308                                     int left,
1309                                     int top,
1310                                     BlendMode blend_type) {
1311   if (m_pBitmap->GetBuffer().empty())
1312     return true;
1313 
1314   if (pBitmap->IsMaskFormat()) {
1315     return m_pBitmap->CompositeMask(left, top, src_rect.Width(),
1316                                     src_rect.Height(), pBitmap, argb,
1317                                     src_rect.left, src_rect.top, blend_type,
1318                                     m_pClipRgn.get(), m_bRgbByteOrder);
1319   }
1320   return m_pBitmap->CompositeBitmap(
1321       left, top, src_rect.Width(), src_rect.Height(), pBitmap, src_rect.left,
1322       src_rect.top, blend_type, m_pClipRgn.get(), m_bRgbByteOrder);
1323 }
1324 
StretchDIBits(const RetainPtr<CFX_DIBBase> & pSource,uint32_t argb,int dest_left,int dest_top,int dest_width,int dest_height,const FX_RECT * pClipRect,const FXDIB_ResampleOptions & options,BlendMode blend_type)1325 bool CFX_AggDeviceDriver::StretchDIBits(const RetainPtr<CFX_DIBBase>& pSource,
1326                                         uint32_t argb,
1327                                         int dest_left,
1328                                         int dest_top,
1329                                         int dest_width,
1330                                         int dest_height,
1331                                         const FX_RECT* pClipRect,
1332                                         const FXDIB_ResampleOptions& options,
1333                                         BlendMode blend_type) {
1334   if (m_pBitmap->GetBuffer().empty())
1335     return true;
1336 
1337   if (dest_width == pSource->GetWidth() &&
1338       dest_height == pSource->GetHeight()) {
1339     FX_RECT rect(0, 0, dest_width, dest_height);
1340     return SetDIBits(pSource, argb, rect, dest_left, dest_top, blend_type);
1341   }
1342   FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width,
1343                     dest_top + dest_height);
1344   dest_rect.Normalize();
1345   FX_RECT dest_clip = dest_rect;
1346   dest_clip.Intersect(*pClipRect);
1347   CFX_BitmapComposer composer;
1348   composer.Compose(m_pBitmap, m_pClipRgn.get(), 255, argb, dest_clip, false,
1349                    false, false, m_bRgbByteOrder, blend_type);
1350   dest_clip.Offset(-dest_rect.left, -dest_rect.top);
1351   CFX_ImageStretcher stretcher(&composer, pSource, dest_width, dest_height,
1352                                dest_clip, options);
1353   if (stretcher.Start())
1354     stretcher.Continue(nullptr);
1355   return true;
1356 }
1357 
StartDIBits(const RetainPtr<CFX_DIBBase> & pSource,int bitmap_alpha,uint32_t argb,const CFX_Matrix & matrix,const FXDIB_ResampleOptions & options,std::unique_ptr<CFX_ImageRenderer> * handle,BlendMode blend_type)1358 bool CFX_AggDeviceDriver::StartDIBits(
1359     const RetainPtr<CFX_DIBBase>& pSource,
1360     int bitmap_alpha,
1361     uint32_t argb,
1362     const CFX_Matrix& matrix,
1363     const FXDIB_ResampleOptions& options,
1364     std::unique_ptr<CFX_ImageRenderer>* handle,
1365     BlendMode blend_type) {
1366   if (m_pBitmap->GetBuffer().empty())
1367     return true;
1368 
1369   *handle = std::make_unique<CFX_ImageRenderer>(
1370       m_pBitmap, m_pClipRgn.get(), pSource, bitmap_alpha, argb, matrix, options,
1371       m_bRgbByteOrder);
1372   return true;
1373 }
1374 
ContinueDIBits(CFX_ImageRenderer * pHandle,PauseIndicatorIface * pPause)1375 bool CFX_AggDeviceDriver::ContinueDIBits(CFX_ImageRenderer* pHandle,
1376                                          PauseIndicatorIface* pPause) {
1377   return m_pBitmap->GetBuffer().empty() || pHandle->Continue(pPause);
1378 }
1379 
1380 }  // namespace pdfium
1381 
AttachAggImpl(RetainPtr<CFX_DIBitmap> pBitmap,bool bRgbByteOrder,RetainPtr<CFX_DIBitmap> pBackdropBitmap,bool bGroupKnockout)1382 bool CFX_DefaultRenderDevice::AttachAggImpl(
1383     RetainPtr<CFX_DIBitmap> pBitmap,
1384     bool bRgbByteOrder,
1385     RetainPtr<CFX_DIBitmap> pBackdropBitmap,
1386     bool bGroupKnockout) {
1387   if (!pBitmap)
1388     return false;
1389 
1390   SetBitmap(pBitmap);
1391   SetDeviceDriver(std::make_unique<pdfium::CFX_AggDeviceDriver>(
1392       std::move(pBitmap), bRgbByteOrder, std::move(pBackdropBitmap),
1393       bGroupKnockout));
1394   return true;
1395 }
1396 
CreateAgg(int width,int height,FXDIB_Format format,RetainPtr<CFX_DIBitmap> pBackdropBitmap)1397 bool CFX_DefaultRenderDevice::CreateAgg(
1398     int width,
1399     int height,
1400     FXDIB_Format format,
1401     RetainPtr<CFX_DIBitmap> pBackdropBitmap) {
1402   auto pBitmap = pdfium::MakeRetain<CFX_DIBitmap>();
1403   if (!pBitmap->Create(width, height, format))
1404     return false;
1405 
1406   SetBitmap(pBitmap);
1407   SetDeviceDriver(std::make_unique<pdfium::CFX_AggDeviceDriver>(
1408       std::move(pBitmap), false, std::move(pBackdropBitmap), false));
1409   return true;
1410 }
1411