tools: skp_parser

tools/debugger/SkDrawCommand.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDrawCommand.h"
 
+#include "png.h"
+
 #include "SkBlurMaskFilter.h"
 #include "SkColorFilter.h"
 #include "SkDashPathEffect.h"
 #include "SkImageFilter.h"
 #include "SkJsonWriteBuffer.h"
 #include "SkMaskFilter.h"
 #include "SkObjectParser.h"
 #include "SkPaintDefaults.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
@@ skipping 634 matching lines @@
 
     (*target) = jsonFlattenable;
     sk_free(data);
 }
 
 static void write_png_callback(png_structp png_ptr, png_bytep data, png_size_t length) {
     SkWStream* out = (SkWStream*) png_get_io_ptr(png_ptr);
     out->write(data, length);
 }
 
-void SkDrawCommand::WritePNG(const png_bytep rgba, png_uint_32 width, png_uint_32 height,
+void SkDrawCommand::WritePNG(const uint8_t* rgba, unsigned width, unsigned height,
                              SkWStream& out, bool isOpaque) {
     png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
     SkASSERT(png != nullptr);
     png_infop info_ptr = png_create_info_struct(png);
     SkASSERT(info_ptr != nullptr);
     if (setjmp(png_jmpbuf(png))) {
         SkFAIL("png encode error");
     }
     png_set_write_fn(png, &out, write_png_callback, NULL);
     int colorType = isOpaque ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGBA;
     png_set_IHDR(png, info_ptr, width, height, 8, colorType, PNG_INTERLACE_NONE,
                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
     png_set_compression_level(png, 1);
     png_bytepp rows = (png_bytepp) sk_malloc_throw(height * sizeof(png_byte*));
     png_bytep pixels = (png_bytep) sk_malloc_throw(width * height * 4);
     for (png_size_t y = 0; y < height; ++y) {
-        const png_bytep src = rgba + y * width * 4;
+        const uint8_t* src = rgba + y * width * 4;
         rows[y] = pixels + y * width * 4;
         for (png_size_t x = 0; x < width; ++x) {
             rows[y][x * 4] = src[x * 4];
             rows[y][x * 4 + 1] = src[x * 4 + 1];
             rows[y][x * 4 + 2] = src[x * 4 + 2];
             rows[y][x * 4 + 3] = src[x * 4 + 3];
         }
     }
     png_write_info(png, info_ptr);
     if (isOpaque) {
@@ skipping 15 matching lines @@
     if (!image.readPixels(dstInfo, buffer.get(), rowBytes, 0, 0)) {
         SkDebugf("readPixels failed\n");
         return false;
     }
 
     SkBitmap bm;
     bm.installPixels(dstInfo, buffer.get(), rowBytes);
     sk_sp<SkData> encodedBitmap = sk_tools::encode_bitmap_for_png(bm);
 
     SkDynamicMemoryWStream out;
-    SkDrawCommand::WritePNG((const png_bytep) encodedBitmap->bytes(), image.width(), image.height(),
+    SkDrawCommand::WritePNG(encodedBitmap->bytes(), image.width(), image.height(),
                             out, false);
     sk_sp<SkData> encoded = out.detachAsData();
     Json::Value jsonData;
     encode_data(encoded->data(), encoded->size(), "image/png", urlDataManager, &jsonData);
     (*target)[SKDEBUGCANVAS_ATTRIBUTE_DATA] = jsonData;
     return true;
 }
 
 static const char* color_type_name(SkColorType colorType) {
     switch (colorType) {
@@ skipping 2805 matching lines @@
 SkTranslateZCommand* SkTranslateZCommand::fromJSON(Json::Value& command,
                                        UrlDataManager& urlDataManager) {
     SkScalar z;
 #ifdef SK_EXPERIMENTAL_SHADOWING
     extract_json_scalar(command[SKDEBUGCANVAS_ATTRIBUTE_DRAWDEPTHTRANS], &z);
 #else
     z = 0;
 #endif
     return new SkTranslateZCommand(z);
 }