Style Change: NULL->nullptr

src/images/SkImageDecoder_libpng.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkMath.h"
 #include "SkRTConf.h"
 #include "SkScaledBitmapSampler.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkUtils.h"
 #include "transform_scanline.h"
 
 #ifdef SKIA_PNG_PREFIXED
     // this must proceed png.h
     #include "pngprefix.h"
 #endif
 #include "png.h"
 
 /* These were dropped in libpng >= 1.4 */
 #ifndef png_infopp_NULL
-#define png_infopp_NULL NULL
+#define png_infopp_NULL nullptr
 #endif
 
 #ifndef png_bytepp_NULL
-#define png_bytepp_NULL NULL
+#define png_bytepp_NULL nullptr
 #endif
 
 #ifndef int_p_NULL
-#define int_p_NULL NULL
+#define int_p_NULL nullptr
 #endif
 
 #ifndef png_flush_ptr_NULL
-#define png_flush_ptr_NULL NULL
+#define png_flush_ptr_NULL nullptr
 #endif
 
 #if defined(SK_DEBUG)
 #define DEFAULT_FOR_SUPPRESS_PNG_IMAGE_DECODER_WARNINGS false
 #else  // !defined(SK_DEBUG)
 #define DEFAULT_FOR_SUPPRESS_PNG_IMAGE_DECODER_WARNINGS true
 #endif  // defined(SK_DEBUG)
 SK_CONF_DECLARE(bool, c_suppressPNGImageDecoderWarnings,
                 "images.png.suppressDecoderWarnings",
                 DEFAULT_FOR_SUPPRESS_PNG_IMAGE_DECODER_WARNINGS,
                 "Suppress most PNG warnings when calling image decode "
                 "functions.");
 
 
 
 class SkPNGImageIndex {
 public:
     // Takes ownership of stream.
     SkPNGImageIndex(SkStreamRewindable* stream, png_structp png_ptr, png_infop info_ptr)
         : fStream(stream)
         , fPng_ptr(png_ptr)
         , fInfo_ptr(info_ptr)
         , fColorType(kUnknown_SkColorType) {
-        SkASSERT(stream != NULL);
+        SkASSERT(stream != nullptr);
     }
     ~SkPNGImageIndex() {
         if (fPng_ptr) {
             png_destroy_read_struct(&fPng_ptr, &fInfo_ptr, png_infopp_NULL);
         }
     }
 
     SkAutoTDelete<SkStreamRewindable>   fStream;
     png_structp                         fPng_ptr;
     png_infop                           fInfo_ptr;
     SkColorType                         fColorType;
 };
 
 class SkPNGImageDecoder : public SkImageDecoder {
 public:
     SkPNGImageDecoder() {
-        fImageIndex = NULL;
+        fImageIndex = nullptr;
     }
     Format getFormat() const override {
         return kPNG_Format;
     }
 
     virtual ~SkPNGImageDecoder() { delete fImageIndex; }
 
 protected:
 #ifdef SK_BUILD_FOR_ANDROID
     bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) override;
@@ skipping 105 matching lines @@
             return false;
     }
 }
 
 // call only if color_type is PALETTE. Returns true if the ctable has alpha
 static bool hasTransparencyInPalette(png_structp png_ptr, png_infop info_ptr) {
     png_bytep trans;
     int num_trans;
 
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-        png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, NULL);
+        png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, nullptr);
         return num_trans > 0;
     }
     return false;
 }
 
 void do_nothing_warning_fn(png_structp, png_const_charp) {
     /* do nothing */
 }
 
 bool SkPNGImageDecoder::onDecodeInit(SkStream* sk_stream, png_structp *png_ptrp,
                                      png_infop *info_ptrp) {
     /* Create and initialize the png_struct with the desired error handler
     * functions.  If you want to use the default stderr and longjump method,
-    * you can supply NULL for the last three parameters.  We also supply the
+    * you can supply nullptr for the last three parameters.  We also supply the
     * the compiler header file version, so that we know if the application
     * was compiled with a compatible version of the library.  */
 
     png_error_ptr user_warning_fn =
-        (c_suppressPNGImageDecoderWarnings) ? (&do_nothing_warning_fn) : NULL;
-    /* NULL means to leave as default library behavior. */
+        (c_suppressPNGImageDecoderWarnings) ? (&do_nothing_warning_fn) : nullptr;
+    /* nullptr means to leave as default library behavior. */
     /* c_suppressPNGImageDecoderWarnings default depends on SK_DEBUG. */
     /* To suppress warnings with a SK_DEBUG binary, set the
      * environment variable "skia_images_png_suppressDecoderWarnings"
      * to "true".  Inside a program that links to skia:
      * SK_CONF_SET("images.png.suppressDecoderWarnings", true); */
 
     png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
-        NULL, sk_error_fn, user_warning_fn);
+        nullptr, sk_error_fn, user_warning_fn);
     //   png_voidp user_error_ptr, user_error_fn, user_warning_fn);
-    if (png_ptr == NULL) {
+    if (png_ptr == nullptr) {
         return false;
     }
 
     *png_ptrp = png_ptr;
 
     /* Allocate/initialize the memory for image information. */
     png_infop info_ptr = png_create_info_struct(png_ptr);
-    if (info_ptr == NULL) {
+    if (info_ptr == nullptr) {
         png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
         return false;
     }
     *info_ptrp = info_ptr;
 
     /* Set error handling if you are using the setjmp/longjmp method (this is
     * the normal method of doing things with libpng).  REQUIRED unless you
     * set up your own error handlers in the png_create_read_struct() earlier.
     */
     if (setjmp(png_jmpbuf(png_ptr))) {
@@ skipping 84 matching lines @@
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return kSuccess;
     }
 
     // from here down we are concerned with colortables and pixels
 
     // we track if we actually see a non-opaque pixels, since sometimes a PNG sets its colortype
     // to |= PNG_COLOR_MASK_ALPHA, but all of its pixels are in fact opaque. We care, since we
     // draw lots faster if we can flag the bitmap has being opaque
     bool reallyHasAlpha = false;
-    SkColorTable* colorTable = NULL;
+    SkColorTable* colorTable = nullptr;
 
     if (pngColorType == PNG_COLOR_TYPE_PALETTE) {
         decodePalette(png_ptr, info_ptr, bitDepth, &hasAlpha, &reallyHasAlpha, &colorTable);
     }
 
     SkAutoUnref aur(colorTable);
 
     if (!this->allocPixelRef(decodedBitmap,
-                             kIndex_8_SkColorType == colorType ? colorTable : NULL)) {
+                             kIndex_8_SkColorType == colorType ? colorTable : nullptr)) {
         return kFailure;
     }
 
     SkAutoLockPixels alp(*decodedBitmap);
 
     // Repeat setjmp, otherwise variables declared since the last call (e.g. alp
     // and aur) won't get their destructors called in case of a failure.
     if (setjmp(png_jmpbuf(png_ptr))) {
         return kFailure;
     }
@@ skipping 24 matching lines @@
         for (int i = 0; i < number_passes; i++) {
             for (png_uint_32 y = 0; y < origHeight; y++) {
                 uint8_t* bmRow = decodedBitmap->getAddr8(0, y);
                 png_read_rows(png_ptr, &bmRow, png_bytepp_NULL, 1);
             }
         }
     } else {
         SkScaledBitmapSampler::SrcConfig sc;
         int srcBytesPerPixel = 4;
 
-        if (colorTable != NULL) {
+        if (colorTable != nullptr) {
             sc = SkScaledBitmapSampler::kIndex;
             srcBytesPerPixel = 1;
         } else if (kAlpha_8_SkColorType == colorType) {
             // A8 is only allowed if the original was GRAY.
             SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType);
             sc = SkScaledBitmapSampler::kGray;
             srcBytesPerPixel = 1;
         } else if (hasAlpha) {
             sc = SkScaledBitmapSampler::kRGBA;
         } else {
             sc = SkScaledBitmapSampler::kRGBX;
         }
 
         /*  We have to pass the colortable explicitly, since we may have one
             even if our decodedBitmap doesn't, due to the request that we
             upscale png's palette to a direct model
          */
-        const SkPMColor* colors = colorTable ? colorTable->readColors() : NULL;
+        const SkPMColor* colors = colorTable ? colorTable->readColors() : nullptr;
         if (!sampler.begin(decodedBitmap, sc, *this, colors)) {
             return kFailure;
         }
         const int height = decodedBitmap->height();
 
         if (number_passes > 1) {
             SkAutoMalloc storage(origWidth * origHeight * srcBytesPerPixel);
             uint8_t* base = (uint8_t*)storage.get();
             size_t rowBytes = origWidth * srcBytesPerPixel;
 
@@ skipping 91 matching lines @@
 #endif
 
     if (colorType == PNG_COLOR_TYPE_PALETTE) {
         bool paletteHasAlpha = hasTransparencyInPalette(png_ptr, info_ptr);
         *colorTypep = this->getPrefColorType(kIndex_SrcDepth, paletteHasAlpha);
         // now see if we can upscale to their requested colortype
         if (!canUpscalePaletteToConfig(*colorTypep, paletteHasAlpha)) {
             *colorTypep = kIndex_8_SkColorType;
         }
     } else {
-        png_color_16p transpColor = NULL;
+        png_color_16p transpColor = nullptr;
         int numTransp = 0;
 
-        png_get_tRNS(png_ptr, info_ptr, NULL, &numTransp, &transpColor);
+        png_get_tRNS(png_ptr, info_ptr, nullptr, &numTransp, &transpColor);
 
         bool valid = png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS);
 
-        if (valid && numTransp == 1 && transpColor != NULL) {
+        if (valid && numTransp == 1 && transpColor != nullptr) {
             /*  Compute our transparent color, which we'll match against later.
                 We don't really handle 16bit components properly here, since we
                 do our compare *after* the values have been knocked down to 8bit
                 which means we will find more matches than we should. The real
                 fix seems to be to see the actual 16bit components, do the
                 compare, and then knock it down to 8bits ourselves.
             */
             if (colorType & PNG_COLOR_MASK_COLOR) {
                 if (16 == bitDepth) {
                     *theTranspColorp = SkPackARGB32(0xFF, transpColor->red >> 8,
@@ skipping 67 matching lines @@
             return false;
         }
     }
 
     // If the image has alpha and the decoder wants unpremultiplied
     // colors, the only supported colortype is 8888.
     if (this->getRequireUnpremultipliedColors() && *hasAlphap) {
         *colorTypep = kN32_SkColorType;
     }
 
-    if (fImageIndex != NULL) {
+    if (fImageIndex != nullptr) {
         if (kUnknown_SkColorType == fImageIndex->fColorType) {
             // This is the first time for this subset decode. From now on,
             // all decodes must be in the same colortype.
             fImageIndex->fColorType = *colorTypep;
         } else if (fImageIndex->fColorType != *colorTypep) {
             // Requesting a different colortype for a subsequent decode is not
             // supported. Report failure before we make changes to png_ptr.
             return false;
         }
     }
@@ skipping 24 matching lines @@
     png_colorp palette;
     png_bytep trans;
     int numTrans;
 
     png_get_PLTE(png_ptr, info_ptr, &palette, &numPalette);
 
     SkPMColor colorStorage[256];    // worst-case storage
     SkPMColor* colorPtr = colorStorage;
 
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-        png_get_tRNS(png_ptr, info_ptr, &trans, &numTrans, NULL);
+        png_get_tRNS(png_ptr, info_ptr, &trans, &numTrans, nullptr);
         *hasAlphap = (numTrans > 0);
     } else {
         numTrans = 0;
     }
 
     // check for bad images that might make us crash
     if (numTrans > numPalette) {
         numTrans = numPalette;
     }
 
@@ skipping 68 matching lines @@
 
     if (fImageIndex) {
         delete fImageIndex;
     }
     fImageIndex = new SkPNGImageIndex(streamDeleter.detach(), png_ptr, info_ptr);
 
     return true;
 }
 
 bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) {
-    if (NULL == fImageIndex) {
+    if (nullptr == fImageIndex) {
         return false;
     }
 
     png_structp png_ptr = fImageIndex->fPng_ptr;
     png_infop info_ptr = fImageIndex->fInfo_ptr;
     if (setjmp(png_jmpbuf(png_ptr))) {
         return false;
     }
 
     png_uint_32 origWidth, origHeight;
@@ skipping 23 matching lines @@
     SkBitmap decodedBitmap;
     decodedBitmap.setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
                                             colorType, kPremul_SkAlphaType));
 
     // from here down we are concerned with colortables and pixels
 
     // we track if we actually see a non-opaque pixels, since sometimes a PNG sets its colortype
     // to |= PNG_COLOR_MASK_ALPHA, but all of its pixels are in fact opaque. We care, since we
     // draw lots faster if we can flag the bitmap has being opaque
     bool reallyHasAlpha = false;
-    SkColorTable* colorTable = NULL;
+    SkColorTable* colorTable = nullptr;
 
     if (pngColorType == PNG_COLOR_TYPE_PALETTE) {
         decodePalette(png_ptr, info_ptr, bitDepth, &hasAlpha, &reallyHasAlpha, &colorTable);
     }
 
     SkAutoUnref aur(colorTable);
 
     // Check ahead of time if the swap(dest, src) is possible.
     // If yes, then we will stick to AllocPixelRef since it's cheaper with the swap happening.
     // If no, then we will use alloc to allocate pixels to prevent garbage collection.
     int w = rect.width() / sampleSize;
     int h = rect.height() / sampleSize;
     const bool swapOnly = (rect == region) && (w == decodedBitmap.width()) &&
                           (h == decodedBitmap.height()) && bm->isNull();
     const bool needColorTable = kIndex_8_SkColorType == colorType;
     if (swapOnly) {
-        if (!this->allocPixelRef(&decodedBitmap, needColorTable ? colorTable : NULL)) {
+        if (!this->allocPixelRef(&decodedBitmap, needColorTable ? colorTable : nullptr)) {
             return false;
         }
     } else {
-        if (!decodedBitmap.tryAllocPixels(NULL, needColorTable ? colorTable : NULL)) {
+        if (!decodedBitmap.tryAllocPixels(nullptr, needColorTable ? colorTable : nullptr)) {
             return false;
         }
     }
     SkAutoLockPixels alp(decodedBitmap);
 
     /* Turn on interlace handling.  REQUIRED if you are not using
     * png_read_image().  To see how to handle interlacing passes,
     * see the png_read_row() method below:
     */
     const int number_passes = (interlaceType != PNG_INTERLACE_NONE) ?
@@ skipping 35 matching lines @@
             png_uint_32 bitmapHeight = (png_uint_32) decodedBitmap.height();
             for (png_uint_32 y = 0; y < bitmapHeight; y++) {
                 uint8_t* bmRow = decodedBitmap.getAddr8(0, y);
                 png_read_rows(png_ptr, &bmRow, png_bytepp_NULL, 1);
             }
         }
     } else {
         SkScaledBitmapSampler::SrcConfig sc;
         int srcBytesPerPixel = 4;
 
-        if (colorTable != NULL) {
+        if (colorTable != nullptr) {
             sc = SkScaledBitmapSampler::kIndex;
             srcBytesPerPixel = 1;
         } else if (kAlpha_8_SkColorType == colorType) {
             // A8 is only allowed if the original was GRAY.
             SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType);
             sc = SkScaledBitmapSampler::kGray;
             srcBytesPerPixel = 1;
         } else if (hasAlpha) {
             sc = SkScaledBitmapSampler::kRGBA;
         } else {
             sc = SkScaledBitmapSampler::kRGBX;
         }
 
         /*  We have to pass the colortable explicitly, since we may have one
             even if our decodedBitmap doesn't, due to the request that we
             upscale png's palette to a direct model
          */
-        const SkPMColor* colors = colorTable ? colorTable->readColors() : NULL;
+        const SkPMColor* colors = colorTable ? colorTable->readColors() : nullptr;
         if (!sampler.begin(&decodedBitmap, sc, *this, colors)) {
             return false;
         }
         const int height = decodedBitmap.height();
 
         if (number_passes > 1) {
             SkAutoMalloc storage(origWidth * origHeight * srcBytesPerPixel);
             uint8_t* base = (uint8_t*)storage.get();
             size_t rb = origWidth * srcBytesPerPixel;
 
@@ skipping 104 matching lines @@
         { kARGB_4444_SkColorType,   true,   transform_scanline_4444 },
         { kIndex_8_SkColorType,     false,  transform_scanline_memcpy },
     };
 
     for (int i = SK_ARRAY_COUNT(gMap) - 1; i >= 0; --i) {
         if (gMap[i].fColorType == ct && gMap[i].fHasAlpha == hasAlpha) {
             return gMap[i].fProc;
         }
     }
     sk_throw();
-    return NULL;
+    return nullptr;
 }
 
 // return the minimum legal bitdepth (by png standards) for this many colortable
 // entries. SkBitmap always stores in 8bits per pixel, but for colorcount <= 16,
 // we can use fewer bits per in png
 static int computeBitDepth(int colorCount) {
 #if 0
     int bits = SkNextLog2(colorCount);
     SkASSERT(bits >= 1 && bits <= 8);
     // now we need bits itself to be a power of 2 (e.g. 1, 2, 4, 8)
     return SkNextPow2(bits);
 #else
     // for the moment, we don't know how to pack bitdepth < 8
     return 8;
 #endif
 }
 
 /*  Pack palette[] with the corresponding colors, and if hasAlpha is true, also
     pack trans[] and return the number of trans[] entries written. If hasAlpha
     is false, the return value will always be 0.
 
     Note: this routine takes care of unpremultiplying the RGB values when we
     have alpha in the colortable, since png doesn't support premul colors
 */
 static inline int pack_palette(SkColorTable* ctable,
                                png_color* SK_RESTRICT palette,
                                png_byte* SK_RESTRICT trans, bool hasAlpha) {
-    const SkPMColor* SK_RESTRICT colors = ctable ? ctable->readColors() : NULL;
+    const SkPMColor* SK_RESTRICT colors = ctable ? ctable->readColors() : nullptr;
     const int ctCount = ctable->count();
     int i, num_trans = 0;
 
     if (hasAlpha) {
         /*  first see if we have some number of fully opaque at the end of the
             ctable. PNG allows num_trans < num_palette, but all of the trans
             entries must come first in the palette. If I was smarter, I'd
             reorder the indices and ctable so that all non-opaque colors came
             first in the palette. But, since that would slow down the encode,
             I'm leaving the indices and ctable order as is, and just looking
@@ skipping 108 matching lines @@
 }
 
 bool SkPNGImageEncoder::doEncode(SkWStream* stream, const SkBitmap& bitmap,
                   const bool& hasAlpha, int colorType,
                   int bitDepth, SkColorType ct,
                   png_color_8& sig_bit) {
 
     png_structp png_ptr;
     png_infop info_ptr;
 
-    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, sk_error_fn,
-                                      NULL);
-    if (NULL == png_ptr) {
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, sk_error_fn,
+                                      nullptr);
+    if (nullptr == png_ptr) {
         return false;
     }
 
     info_ptr = png_create_info_struct(png_ptr);
-    if (NULL == info_ptr) {
+    if (nullptr == info_ptr) {
         png_destroy_write_struct(&png_ptr,  png_infopp_NULL);
         return false;
     }
 
     /* Set error handling.  REQUIRED if you aren't supplying your own
     * error handling functions in the png_create_write_struct() call.
     */
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_write_struct(&png_ptr, &info_ptr);
         return false;
@@ skipping 16 matching lines @@
                  PNG_FILTER_TYPE_BASE);
 
     // set our colortable/trans arrays if needed
     png_color paletteColors[256];
     png_byte trans[256];
     if (kIndex_8_SkColorType == ct) {
         SkColorTable* ct = bitmap.getColorTable();
         int numTrans = pack_palette(ct, paletteColors, trans, hasAlpha);
         png_set_PLTE(png_ptr, info_ptr, paletteColors, ct->count());
         if (numTrans > 0) {
-            png_set_tRNS(png_ptr, info_ptr, trans, numTrans, NULL);
+            png_set_tRNS(png_ptr, info_ptr, trans, numTrans, nullptr);
         }
     }
 #ifdef PNG_sBIT_SUPPORTED
     png_set_sBIT(png_ptr, info_ptr, &sig_bit);
 #endif
     png_write_info(png_ptr, info_ptr);
 
     const char* srcImage = (const char*)bitmap.getPixels();
     SkAutoSMalloc<1024> rowStorage(bitmap.width() << 2);
     char* storage = (char*)rowStorage.get();
@@ skipping 24 matching lines @@
         !png_sig_cmp((png_bytep) buf, (png_size_t)0, PNG_BYTES_TO_CHECK)) {
         return true;
     }
     return false;
 }
 
 SkImageDecoder* sk_libpng_dfactory(SkStreamRewindable* stream) {
     if (is_png(stream)) {
         return new SkPNGImageDecoder;
     }
-    return NULL;
+    return nullptr;
 }
 
 static SkImageDecoder::Format get_format_png(SkStreamRewindable* stream) {
     if (is_png(stream)) {
         return SkImageDecoder::kPNG_Format;
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
-    return (SkImageEncoder::kPNG_Type == t) ? new SkPNGImageEncoder : NULL;
+    return (SkImageEncoder::kPNG_Type == t) ? new SkPNGImageEncoder : nullptr;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libpng_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_png);
 static SkImageEncoder_EncodeReg gEReg(sk_libpng_efactory);