Remove FX_GAMMA() and friends. They do nothing.

core/fxge/agg/fx_agg_driver.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 "core/fxge/agg/fx_agg_driver.h"
 
 #include <algorithm>
 
@@ skipping 182 matching lines @@
                                  bGroupKnockout);
 }
 
 CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap,
                                          int dither_bits,
                                          FX_BOOL bRgbByteOrder,
                                          CFX_DIBitmap* pOriDevice,
                                          FX_BOOL bGroupKnockout) {
   m_pBitmap = pBitmap;
   m_DitherBits = dither_bits;
-  m_pClipRgn = NULL;
-  m_pPlatformBitmap = NULL;
-  m_pPlatformGraphics = NULL;
-  m_pDwRenderTartget = NULL;
+  m_pClipRgn = nullptr;
+  m_pPlatformBitmap = nullptr;
+  m_pPlatformGraphics = nullptr;
+  m_pDwRenderTartget = nullptr;
   m_bRgbByteOrder = bRgbByteOrder;
   m_pOriDevice = pOriDevice;
   m_bGroupKnockout = bGroupKnockout;
   m_FillFlags = 0;
   InitPlatform();
 }
 
 CFX_AggDeviceDriver::~CFX_AggDeviceDriver() {
   delete m_pClipRgn;
   for (int i = 0; i < m_StateStack.GetSize(); i++)
@@ skipping 53 matching lines @@
       }
       return flags;
     }
     case FXDC_DITHER_BITS:
       return m_DitherBits;
   }
   return 0;
 }
 
 void CFX_AggDeviceDriver::SaveState() {
-  CFX_ClipRgn* pClip = NULL;
+  CFX_ClipRgn* pClip = nullptr;
   if (m_pClipRgn) {
     pClip = new CFX_ClipRgn(*m_pClipRgn);
   }
   m_StateStack.Add(pClip);
 }
 
 void CFX_AggDeviceDriver::RestoreState(FX_BOOL bKeepSaved) {
   if (m_StateStack.GetSize() == 0) {
     delete m_pClipRgn;
-    m_pClipRgn = NULL;
+    m_pClipRgn = nullptr;
     return;
   }
   CFX_ClipRgn* pSavedClip = m_StateStack[m_StateStack.GetSize() - 1];
   delete m_pClipRgn;
-  m_pClipRgn = NULL;
+  m_pClipRgn = nullptr;
   if (bKeepSaved) {
     if (pSavedClip) {
       m_pClipRgn = new CFX_ClipRgn(*pSavedClip);
     }
   } else {
     m_StateStack.RemoveAt(m_StateStack.GetSize() - 1);
     m_pClipRgn = pSavedClip;
   }
 }
 
@@ skipping 57 matching lines @@
 
 FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pPathData,
     const CFX_Matrix* pObject2Device,
     const CFX_GraphStateData* pGraphState) {
   if (!m_pClipRgn) {
     m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH),
                                  GetDeviceCaps(FXDC_PIXEL_HEIGHT));
   }
   CAgg_PathData path_data;
-  path_data.BuildPath(pPathData, NULL);
+  path_data.BuildPath(pPathData, nullptr);
   agg::rasterizer_scanline_aa rasterizer;
   rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                       (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
   RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device,
                   pGraphState);
   rasterizer.filling_rule(agg::fill_non_zero);
   SetClipMask(rasterizer);
   return TRUE;
 }
 
@@ skipping 637 matching lines @@
   template <class Scanline>
   void render(const Scanline& sl) {
     if (!m_pOriDevice && !composite_span) {
       return;
     }
     int y = sl.y();
     if (y < m_ClipBox.top || y >= m_ClipBox.bottom) {
       return;
     }
     uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * y;
-    uint8_t* dest_scan_extra_alpha = NULL;
+    uint8_t* dest_scan_extra_alpha = nullptr;
     CFX_DIBitmap* pAlphaMask = m_pDevice->m_pAlphaMask;
     if (pAlphaMask) {
       dest_scan_extra_alpha =
           pAlphaMask->GetBuffer() + pAlphaMask->GetPitch() * y;
     }
-    uint8_t* ori_scan = NULL;
+    uint8_t* ori_scan = nullptr;
     if (m_pOriDevice) {
       ori_scan = m_pOriDevice->GetBuffer() + m_pOriDevice->GetPitch() * y;
     }
     int Bpp = m_pDevice->GetBPP() / 8;
     FX_BOOL bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask();
     unsigned num_spans = sl.num_spans();
     typename Scanline::const_iterator span = sl.begin();
     while (1) {
       int x = span->x;
       ASSERT(span->len > 0);
-      uint8_t* dest_pos = NULL;
-      uint8_t* dest_extra_alpha_pos = NULL;
-      uint8_t* ori_pos = NULL;
+      uint8_t* dest_pos = nullptr;
+      uint8_t* dest_extra_alpha_pos = nullptr;
+      uint8_t* ori_pos = nullptr;
       if (Bpp) {
-        ori_pos = ori_scan ? ori_scan + x * Bpp : NULL;
+        ori_pos = ori_scan ? ori_scan + x * Bpp : nullptr;
         dest_pos = dest_scan + x * Bpp;
         dest_extra_alpha_pos =
-            dest_scan_extra_alpha ? dest_scan_extra_alpha + x : NULL;
+            dest_scan_extra_alpha ? dest_scan_extra_alpha + x : nullptr;
       } else {
         dest_pos = dest_scan + x / 8;
-        ori_pos = ori_scan ? ori_scan + x / 8 : NULL;
+        ori_pos = ori_scan ? ori_scan + x / 8 : nullptr;
       }
-      uint8_t* clip_pos = NULL;
+      uint8_t* clip_pos = nullptr;
       if (m_pClipMask) {
         clip_pos = m_pClipMask->GetBuffer() +
                    (y - m_ClipBox.top) * m_pClipMask->GetPitch() + x -
                    m_ClipBox.left;
       }
       if (ori_pos) {
         CompositeSpan(dest_pos, ori_pos, Bpp, bDestAlpha, x, span->len,
                       span->covers, m_ClipBox.left, m_ClipBox.right, clip_pos);
       } else {
         (this->*composite_span)(dest_pos, Bpp, x, span->len, span->covers,
                                 m_ClipBox.left, m_ClipBox.right, clip_pos,
                                 dest_extra_alpha_pos);
       }
       if (--num_spans == 0) {
         break;
       }
       ++span;
     }
   }
 
   FX_BOOL Init(CFX_DIBitmap* pDevice,
                CFX_DIBitmap* pOriDevice,
                const CFX_ClipRgn* pClipRgn,
                uint32_t color,
                FX_BOOL bFullCover,
                FX_BOOL bRgbByteOrder,
                int alpha_flag = 0,
-               void* pIccTransform = NULL) {
+               void* pIccTransform = nullptr) {
     m_pDevice = pDevice;
     m_pClipRgn = pClipRgn;
-    composite_span = NULL;
+    composite_span = nullptr;
     m_bRgbByteOrder = bRgbByteOrder;
     m_pOriDevice = pOriDevice;
     if (m_pClipRgn) {
       m_ClipBox = m_pClipRgn->GetBox();
     } else {
       m_ClipBox.left = m_ClipBox.top = 0;
       m_ClipBox.right = m_pDevice->GetWidth();
       m_ClipBox.bottom = m_pDevice->GetHeight();
     }
-    m_pClipMask = NULL;
+    m_pClipMask = nullptr;
     if (m_pClipRgn && m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) {
       m_pClipMask = m_pClipRgn->GetMask();
     }
     m_bFullCover = bFullCover;
     FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
     FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
     m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
-    CCodec_IccModule* pIccModule = NULL;
+    CCodec_IccModule* pIccModule = nullptr;
     if (!CFX_GEModule::Get()->GetCodecModule() ||
         !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-      pIccTransform = NULL;
+      pIccTransform = nullptr;
     } else {
       pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (m_pDevice->GetBPP() == 8) {
       ASSERT(!m_bRgbByteOrder);
       composite_span = &CFX_Renderer::CompositeSpanGray;
       if (m_pDevice->IsAlphaMask()) {
         m_Gray = 255;
       } else {
         if (pIccTransform) {
@@ skipping 86 matching lines @@
   }
 };
 
 FX_BOOL CFX_AggDeviceDriver::RenderRasterizer(
     agg::rasterizer_scanline_aa& rasterizer,
     uint32_t color,
     FX_BOOL bFullCover,
     FX_BOOL bGroupKnockout,
     int alpha_flag,
     void* pIccTransform) {
-  CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : NULL;
+  CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : nullptr;
   CFX_Renderer render;
   if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover,
                    m_bRgbByteOrder, alpha_flag, pIccTransform)) {
     return FALSE;
   }
   agg::scanline_u8 scanline;
   agg::render_scanlines(rasterizer, scanline, render,
                         (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
   return TRUE;
 }
@@ skipping 33 matching lines @@
                          ? FXGETFLAG_ALPHA_STROKE(alpha_flag)
                          : FXARGB_A(stroke_color);
   if (pGraphState && stroke_alpha) {
     if (fill_mode & FX_ZEROAREA_FILL) {
       CAgg_PathData path_data;
       path_data.BuildPath(pPathData, pObject2Device);
       agg::rasterizer_scanline_aa rasterizer;
       rasterizer.clip_box(0.0f, 0.0f,
                           (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                           (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
-      RasterizeStroke(rasterizer, path_data.m_PathData, NULL, pGraphState, 1,
+      RasterizeStroke(rasterizer, path_data.m_PathData, nullptr, pGraphState, 1,
                       FALSE, fill_mode & FX_STROKE_TEXT_MODE);
       int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 |
                       FXGETFLAG_ALPHA_STROKE(alpha_flag);
       if (!RenderRasterizer(rasterizer, stroke_color,
                             fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout,
                             fill_flag, pIccTransform)) {
         return FALSE;
       }
       return TRUE;
     }
@@ skipping 28 matching lines @@
   return TRUE;
 }
 
 void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, uint32_t argb) {
   if (x < 0 || x >= pBitmap->GetWidth() || y < 0 || y >= pBitmap->GetHeight()) {
     return;
   }
   uint8_t* pos = (uint8_t*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() +
                  x * pBitmap->GetBPP() / 8;
   if (pBitmap->GetFormat() == FXDIB_Argb) {
-    FXARGB_SETRGBORDERDIB(pos, ArgbGamma(argb));
+    FXARGB_SETRGBORDERDIB(pos, argb);
   } else {
     int alpha = FXARGB_A(argb);
     pos[0] = (FXARGB_R(argb) * alpha + pos[0] * (255 - alpha)) / 255;
     pos[1] = (FXARGB_G(argb) * alpha + pos[1] * (255 - alpha)) / 255;
     pos[2] = (FXARGB_B(argb) * alpha + pos[2] * (255 - alpha)) / 255;
   }
 }
 
 void RgbByteOrderCompositeRect(CFX_DIBitmap* pBitmap,
                                int left,
@@ skipping 25 matching lines @@
       } else {
         for (int col = 0; col < width; col++) {
           *dest_scan++ = src_r;
           *dest_scan++ = src_g;
           *dest_scan++ = src_b;
         }
       }
     }
     return;
   }
-  src_r = FX_GAMMA(src_r);
-  src_g = FX_GAMMA(src_g);
-  src_b = FX_GAMMA(src_b);
   for (int row = rect.top; row < rect.bottom; row++) {
     uint8_t* dest_scan = pBuffer + row * pBitmap->GetPitch() + rect.left * Bpp;
     if (bAlpha) {
       for (int col = 0; col < width; col++) {
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
           FXARGB_SETRGBORDERDIB(dest_scan,
                                 FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
           dest_scan += 4;
           continue;
         }
         uint8_t dest_alpha =
             back_alpha + src_alpha - back_alpha * src_alpha / 255;
         dest_scan[3] = dest_alpha;
         int alpha_ratio = src_alpha * 255 / dest_alpha;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
         dest_scan++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
         dest_scan++;
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
         dest_scan += 2;
       }
     } else {
       for (int col = 0; col < width; col++) {
-        *dest_scan = FX_GAMMA_INVERSE(
-            FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_r, src_alpha));
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, src_alpha);
         dest_scan++;
-        *dest_scan = FX_GAMMA_INVERSE(
-            FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_g, src_alpha));
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, src_alpha);
         dest_scan++;
-        *dest_scan = FX_GAMMA_INVERSE(
-            FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_b, src_alpha));
+        *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, src_alpha);
         dest_scan++;
         if (Bpp == 4) {
           dest_scan++;
         }
       }
     }
   }
 }
 
 void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap,
                                 int dest_left,
                                 int dest_top,
                                 int width,
                                 int height,
                                 const CFX_DIBSource* pSrcBitmap,
                                 int src_left,
                                 int src_top) {
   if (!pBitmap) {
     return;
   }
   pBitmap->GetOverlapRect(dest_left, dest_top, width, height,
                           pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(),
-                          src_left, src_top, NULL);
+                          src_left, src_top, nullptr);
   if (width == 0 || height == 0) {
     return;
   }
   int Bpp = pBitmap->GetBPP() / 8;
   FXDIB_Format dest_format = pBitmap->GetFormat();
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
   int pitch = pBitmap->GetPitch();
   uint8_t* buffer = pBitmap->GetBuffer();
   if (dest_format == src_format) {
     for (int row = 0; row < height; row++) {
@@ skipping 34 matching lines @@
       }
     } else {
       ASSERT(FALSE);
     }
   } else if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) {
     if (src_format == FXDIB_Rgb) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = (uint8_t*)(dest_buf + row * pitch);
         uint8_t* src_scan =
             (uint8_t*)pSrcBitmap->GetScanline(src_top + row) + src_left * 3;
-        if (src_format == FXDIB_Argb) {
-          for (int col = 0; col < width; col++) {
-            FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, FX_GAMMA(src_scan[0]),
-                                                 FX_GAMMA(src_scan[1]),
-                                                 FX_GAMMA(src_scan[2])));
-            dest_scan += 4;
-            src_scan += 3;
-          }
-        } else {
-          for (int col = 0; col < width; col++) {
-            FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
-                                                 src_scan[2]));
-            dest_scan += 4;
-            src_scan += 3;
-          }
+        for (int col = 0; col < width; col++) {
+          FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
+                                               src_scan[2]));
+          dest_scan += 4;
+          src_scan += 3;
         }
       }
     } else if (src_format == FXDIB_Rgb32) {
       ASSERT(dest_format == FXDIB_Argb);
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = dest_buf + row * pitch;
         uint8_t* src_scan =
             (uint8_t*)(pSrcBitmap->GetScanline(src_top + row) + src_left * 4);
         for (int col = 0; col < width; col++) {
           FXARGB_SETDIB(dest_scan, FXARGB_MAKE(0xff, src_scan[0], src_scan[1],
@@ skipping 54 matching lines @@
 FX_BOOL CFX_AggDeviceDriver::SetPixel(int x,
                                       int y,
                                       uint32_t color,
                                       int alpha_flag,
                                       void* pIccTransform) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-    pIccTransform = NULL;
+    pIccTransform = nullptr;
   }
   if (!m_pClipRgn) {
     if (m_bRgbByteOrder) {
       RgbByteOrderSetPixel(m_pBitmap, x, y, color);
     } else {
       return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform);
     }
   } else if (m_pClipRgn->GetBox().Contains(x, y)) {
     if (m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
       if (m_bRgbByteOrder) {
@@ skipping 52 matching lines @@
       m_pBitmap->CompositeRect(draw_rect.left, draw_rect.top, draw_rect.Width(),
                                draw_rect.Height(), fill_color, alpha_flag,
                                pIccTransform);
     }
     return TRUE;
   }
   m_pBitmap->CompositeMask(
       draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(),
       (const CFX_DIBitmap*)m_pClipRgn->GetMask(), fill_color,
       draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top,
-      FXDIB_BLEND_NORMAL, NULL, m_bRgbByteOrder, alpha_flag, pIccTransform);
+      FXDIB_BLEND_NORMAL, nullptr, m_bRgbByteOrder, alpha_flag, pIccTransform);
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect) {
   if (!m_pClipRgn) {
     pRect->left = pRect->top = 0;
     pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH);
     pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT);
     return TRUE;
   }
@@ skipping 15 matching lines @@
                                  pBitmap->GetHeight(), m_pBitmap, left, top);
     } else {
       return pBitmap->TransferBitmap(0, 0, pBitmap->GetWidth(),
                                      pBitmap->GetHeight(), m_pBitmap, left, top,
                                      pIccTransform);
     }
     return TRUE;
   }
   FX_RECT rect(left, top, left + pBitmap->GetWidth(),
                top + pBitmap->GetHeight());
-  CFX_DIBitmap* pBack = NULL;
+  CFX_DIBitmap* pBack = nullptr;
   if (m_pOriDevice) {
     pBack = m_pOriDevice->Clone(&rect);
     if (!pBack) {
       return TRUE;
     }
     pBack->CompositeBitmap(0, 0, pBack->GetWidth(), pBack->GetHeight(),
                            m_pBitmap, 0, 0);
   } else {
     pBack = m_pBitmap->Clone(&rect);
   }
@@ skipping 142 matching lines @@
   SetDeviceDriver(pDriver);
   return true;
 }
 
 CFX_FxgeDevice::~CFX_FxgeDevice() {
   if (m_bOwnedBitmap) {
     delete GetBitmap();
   }
 }
 #endif