kc3-lang/angle/src/image_util/storeimage_paletted.cpp

• Show log

  Commit

• Hash : 25390156
  Author :
  Date : 2025-08-21T00:13:19
  

  Suppress unsafe buffers on a file-by-file basis in src/ [1 of N]
  
  In this CL, we suppress many files but stop short of actually
  enabling the warning by not removing the line from the
  unsafe_buffers_paths.txt file. That will happen in a follow-on
  CL, along with resolving any stragglers missed here.
  
  This is mostly a manual change so as to familiarize myself with
  the kinds of issues faced by the Angle codebase when applying buffer
  safety warnings.
  
  -- Re-generate affected hashes.
  -- Clang-format applied to all changed files.
  -- Add a few missing .reserve() calls to vectors as noticed.
  -- Fix some mismatches between file names and header comments.
  -- Be more consistent with header comment format (blank lines and
     trailing //-only lines when a filename comment adjoins license
     boilerplate).
  
  Bug: b/436880895
  Change-Id: I3bde5cc2059acbe8345057289214f1a26f1c34aa
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6869022
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/image_util/storeimage_paletted.cpp

• //
  // Copyright 2022 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #ifdef UNSAFE_BUFFERS_BUILD
  #    pragma allow_unsafe_buffers
  #endif
  
  // storeimage_paletted.cpp: Encodes GL_PALETTE_* textures.
  
  #include <unordered_map>
  
  #include "image_util/storeimage.h"
  
  #include <type_traits>
  #include "common/mathutil.h"
  
  #include "image_util/imageformats.h"
  
  namespace angle
  {
  
  namespace
  {
  
  template <typename T>
  inline T *OffsetDataPointer(uint8_t *data, size_t y, size_t z, size_t rowPitch, size_t depthPitch)
  {
      return reinterpret_cast<T *>(data + (y * rowPitch) + (z * depthPitch));
  }
  
  template <typename T>
  inline const T *OffsetDataPointer(const uint8_t *data,
                                    size_t y,
                                    size_t z,
                                    size_t rowPitch,
                                    size_t depthPitch)
  {
      return reinterpret_cast<const T *>(data + (y * rowPitch) + (z * depthPitch));
  }
  
  void EncodeColor(R8G8B8A8 rgba,
                   uint32_t redBlueBits,
                   uint32_t greenBits,
                   uint32_t alphaBits,
                   void *dst)
  {
      gl::ColorF color;
      R8G8B8A8::readColor(&color, &rgba);
  
      switch (redBlueBits)
      {
          case 8:
              ASSERT(greenBits == 8);
              switch (alphaBits)
              {
                  case 0:
                      return R8G8B8::writeColor(reinterpret_cast<R8G8B8 *>(dst), &color);
                  case 8:
                      return R8G8B8A8::writeColor(reinterpret_cast<R8G8B8A8 *>(dst), &color);
                  default:
                      UNREACHABLE();
                      break;
              }
              break;
  
          case 5:
              switch (greenBits)
              {
                  case 6:
                      ASSERT(alphaBits == 0);
                      return R5G6B5::writeColor(reinterpret_cast<R5G6B5 *>(dst), &color);
                  case 5:
                      ASSERT(alphaBits == 1);
                      return R5G5B5A1::writeColor(reinterpret_cast<R5G5B5A1 *>(dst), &color);
                  default:
                      UNREACHABLE();
                      break;
              }
              break;
  
          case 4:
              ASSERT(greenBits == 4 && alphaBits == 4);
              return R4G4B4A4::writeColor(reinterpret_cast<R4G4B4A4 *>(dst), &color);
  
          default:
              UNREACHABLE();
              break;
      }
  }
  
  uint32_t R8G8B8A8Key(R8G8B8A8 rgba)
  {
      uint32_t key;
      static_assert(sizeof(key) == sizeof(rgba));
      memcpy(&key, &rgba, sizeof(key));
      return key;
  }
  
  }  // namespace
  
  void StoreRGBA8ToPalettedImpl(size_t width,
                                size_t height,
                                size_t depth,
                                uint32_t indexBits,
                                uint32_t redBlueBits,
                                uint32_t greenBits,
                                uint32_t alphaBits,
                                const uint8_t *input,
                                size_t inputRowPitch,
                                size_t inputDepthPitch,
                                uint8_t *output,
                                size_t outputRowPitch,
                                size_t outputDepthPitch)
  {
      std::unordered_map<uint32_t, size_t> invPalette;
  
      ASSERT((redBlueBits + greenBits + redBlueBits + alphaBits) % 8 == 0);
  
      size_t colorBytes   = (redBlueBits + greenBits + redBlueBits + alphaBits) / 8;
      size_t paletteSize  = 1 << indexBits;
      size_t paletteBytes = paletteSize * colorBytes;
  
      uint8_t *palette = output;
  
      // We might not fill-out the entire palette.
      memset(palette, 0xab, paletteBytes);
  
      uint8_t *texels = output + paletteBytes;  // + TODO(http://anglebug.com/42266155): mip levels
  
      for (size_t z = 0; z < depth; z++)
      {
          for (size_t y = 0; y < height; y++)
          {
              const R8G8B8A8 *srcRow =
                  OffsetDataPointer<R8G8B8A8>(input, y, z, inputRowPitch, inputDepthPitch);
              uint8_t *dstRow =
                  OffsetDataPointer<uint8_t>(texels, y, z, outputRowPitch, outputDepthPitch);
  
              for (size_t x = 0; x < width; x++)
              {
                  auto inversePaletteEntry = invPalette.insert(
                      std::pair<uint32_t, size_t>(R8G8B8A8Key(srcRow[x]), invPalette.size()));
                  size_t paletteIndex = inversePaletteEntry.first->second;
                  ASSERT(paletteIndex < paletteSize);
                  if (inversePaletteEntry.second)
                  {
                      EncodeColor(srcRow[x], redBlueBits, greenBits, alphaBits,
                                  palette + paletteIndex * colorBytes);
                  }
  
                  switch (indexBits)
                  {
                      case 4:
                          // On even xses, initialize the location and store the high
                          // bits, on odd (which always follows even) store the low
                          // bits.
                          if (x % 2 == 0)
                              dstRow[x / 2] = static_cast<uint8_t>(paletteIndex) << 4;
                          else
                              dstRow[x / 2] |= static_cast<uint8_t>(paletteIndex);
                          break;
  
                      case 8:
                          dstRow[x] = static_cast<uint8_t>(paletteIndex);
                          break;
  
                      default:
                          UNREACHABLE();
                  }
              }
          }
      }
  }
  
  }  // namespace angle
  

Download