text: /*
   * Copyright 2011 Google Inc.
   *
   * Use of this source code is governed by a BSD-style license that can be
   * found in the LICENSE file.
   */
  #ifndef SkPDFUtils_DEFINED
  #define SkPDFUtils_DEFINED
  
  #include "SkFloatToDecimal.h"
  #include "SkPDFTypes.h"
  #include "SkPaint.h"
  #include "SkPath.h"
  #include "SkShader.h"
  #include "SkStream.h"
  #include "SkUtils.h"
  
  class SkMatrix;
  class SkPDFArray;
  struct SkRect;
  
  template <typename T>
  bool SkPackedArrayEqual(T* u, T* v, size_t n) {
      SkASSERT(u);
      SkASSERT(v);
      return 0 == memcmp(u, v, n * sizeof(T));
  }
  
  #if 0
  #define PRINT_NOT_IMPL(str) fprintf(stderr, str)
  #else
  #define PRINT_NOT_IMPL(str)
  #endif
  
  #define NOT_IMPLEMENTED(condition, assert)                         \
      do {                                                           \
          if ((bool)(condition)) {                                   \
              PRINT_NOT_IMPL("NOT_IMPLEMENTED: " #condition "\n");   \
              SkDEBUGCODE(SkASSERT(!assert);)                        \
          }                                                          \
      } while (0)
  
  namespace SkPDFUtils {
  
  const char* BlendModeName(SkBlendMode);
  
  std::unique_ptr<SkPDFArray> RectToArray(const SkRect& rect);
  std::unique_ptr<SkPDFArray> MatrixToArray(const SkMatrix& matrix);
  
  void MoveTo(SkScalar x, SkScalar y, SkWStream* content);
  void AppendLine(SkScalar x, SkScalar y, SkWStream* content);
  void AppendRectangle(const SkRect& rect, SkWStream* content);
  void EmitPath(const SkPath& path, SkPaint::Style paintStyle,
                bool doConsumeDegerates, SkWStream* content, SkScalar tolerance = 0.25f);
  inline void EmitPath(const SkPath& path, SkPaint::Style paintStyle,
                       SkWStream* content, SkScalar tolerance = 0.25f) {
      SkPDFUtils::EmitPath(path, paintStyle, true, content, tolerance);
  }
  void ClosePath(SkWStream* content);
  void PaintPath(SkPaint::Style style, SkPath::FillType fill,
                        SkWStream* content);
  void StrokePath(SkWStream* content);
  void ApplyGraphicState(int objectIndex, SkWStream* content);
  void ApplyPattern(int objectIndex, SkWStream* content);
  
  // Converts (value / 255.0) with three significant digits of accuracy.
  // Writes value as string into result.  Returns strlen() of result.
  size_t ColorToDecimal(uint8_t value, char result[5]);
  
  static constexpr unsigned kFloatColorDecimalCount = 4;
  size_t ColorToDecimalF(float value, char result[kFloatColorDecimalCount + 2]);
  inline void AppendColorComponent(uint8_t value, SkWStream* wStream) {
      char buffer[5];
      size_t len = SkPDFUtils::ColorToDecimal(value, buffer);
      wStream->write(buffer, len);
  }
  inline void AppendColorComponentF(float value, SkWStream* wStream) {
      char buffer[kFloatColorDecimalCount + 2];
      size_t len = SkPDFUtils::ColorToDecimalF(value, buffer);
      wStream->write(buffer, len);
  }
  
  inline void AppendScalar(SkScalar value, SkWStream* stream) {
      char result[kMaximumSkFloatToDecimalLength];
      size_t len = SkFloatToDecimal(SkScalarToFloat(value), result);
      SkASSERT(len < kMaximumSkFloatToDecimalLength);
      stream->write(result, len);
  }
  
  inline void WriteUInt16BE(SkDynamicMemoryWStream* wStream, uint16_t value) {
      char result[4] = { SkHexadecimalDigits::gUpper[       value >> 12 ],
                         SkHexadecimalDigits::gUpper[0xF & (value >> 8 )],
                         SkHexadecimalDigits::gUpper[0xF & (value >> 4 )],
                         SkHexadecimalDigits::gUpper[0xF & (value      )] };
      wStream->write(result, 4);
  }
  
  inline void WriteUInt8(SkDynamicMemoryWStream* wStream, uint8_t value) {
      char result[2] = { SkHexadecimalDigits::gUpper[value >> 4],
                         SkHexadecimalDigits::gUpper[value & 0xF] };
      wStream->write(result, 2);
  }
  
  inline void WriteUTF16beHex(SkDynamicMemoryWStream* wStream, SkUnichar utf32) {
      uint16_t utf16[2] = {0, 0};
      size_t len = SkUTF::ToUTF16(utf32, utf16);
      SkASSERT(len == 1 || len == 2);
      SkPDFUtils::WriteUInt16BE(wStream, utf16[0]);
      if (len == 2) {
          SkPDFUtils::WriteUInt16BE(wStream, utf16[1]);
      }
  }
  
  inline SkMatrix GetShaderLocalMatrix(const SkShader* shader) {
      SkMatrix localMatrix;
      if (sk_sp<SkShader> s = shader->makeAsALocalMatrixShader(&localMatrix)) {
          return SkMatrix::Concat(s->getLocalMatrix(), localMatrix);
      }
      return shader->getLocalMatrix();
  }
  bool InverseTransformBBox(const SkMatrix& matrix, SkRect* bbox);
  void PopulateTilingPatternDict(SkPDFDict* pattern,
                                 SkRect& bbox,
                                 std::unique_ptr<SkPDFDict> resources,
                                 const SkMatrix& matrix);
  
  bool ToBitmap(const SkImage* img, SkBitmap* dst);
  
  #ifdef SK_PDF_BASE85_BINARY
  void Base85Encode(std::unique_ptr<SkStreamAsset> src, SkDynamicMemoryWStream* dst);
  #endif //  SK_PDF_BASE85_BINARY
  
  }  // namespace SkPDFUtils
  
  #endif
  