Style Change: NULL->nullptr

src/images/SkImageDecoder_libjpeg.cpp

 /*
  * Copyright 2007 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"
@@ skipping 47 matching lines @@
 //////////////////////////////////////////////////////////////////////////
 
 static void do_nothing_emit_message(jpeg_common_struct*, int) {
     /* do nothing */
 }
 static void do_nothing_output_message(j_common_ptr) {
     /* do nothing */
 }
 
 static void initialize_info(jpeg_decompress_struct* cinfo, skjpeg_source_mgr* src_mgr) {
-    SkASSERT(cinfo != NULL);
-    SkASSERT(src_mgr != NULL);
+    SkASSERT(cinfo != nullptr);
+    SkASSERT(src_mgr != nullptr);
     jpeg_create_decompress(cinfo);
     cinfo->src = src_mgr;
     /* To suppress warnings with a SK_DEBUG binary, set the
      * environment variable "skia_images_jpeg_suppressDecoderWarnings"
      * to "true".  Inside a program that links to skia:
      * SK_CONF_SET("images.jpeg.suppressDecoderWarnings", true); */
     if (c_suppressJPEGImageDecoderWarnings) {
         cinfo->err->emit_message = &do_nothing_emit_message;
     }
     /* To suppress error messages with a SK_DEBUG binary, set the
@@ skipping 118 matching lines @@
     bool fHuffmanCreated;
     bool fDecompressStarted;
     SkDEBUGCODE(bool fReadHeaderSucceeded;)
 };
 #endif
 
 class SkJPEGImageDecoder : public SkImageDecoder {
 public:
 #ifdef SK_BUILD_FOR_ANDROID
     SkJPEGImageDecoder() {
-        fImageIndex = NULL;
+        fImageIndex = nullptr;
         fImageWidth = 0;
         fImageHeight = 0;
     }
 
     virtual ~SkJPEGImageDecoder() { delete fImageIndex; }
 #endif
 
     Format getFormat() const override {
         return kJPEG_Format;
     }
@@ skipping 24 matching lines @@
     SkColorType getBitmapColorType(jpeg_decompress_struct*);
 
     typedef SkImageDecoder INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////
 
 /* Automatically clean up after throwing an exception */
 class JPEGAutoClean {
 public:
-    JPEGAutoClean(): cinfo_ptr(NULL) {}
+    JPEGAutoClean(): cinfo_ptr(nullptr) {}
     ~JPEGAutoClean() {
         if (cinfo_ptr) {
             jpeg_destroy_decompress(cinfo_ptr);
         }
     }
     void set(jpeg_decompress_struct* info) {
         cinfo_ptr = info;
     }
 private:
     jpeg_decompress_struct* cinfo_ptr;
@@ skipping 101 matching lines @@
         scanline[1] = SkMulDiv255Round(scanline[1], scanline[3]);
         scanline[2] = SkMulDiv255Round(scanline[2], scanline[3]);
         scanline[3] = 255;
     }
 }
 
 /**
  *  Common code for setting the error manager.
  */
 static void set_error_mgr(jpeg_decompress_struct* cinfo, skjpeg_error_mgr* errorManager) {
-    SkASSERT(cinfo != NULL);
-    SkASSERT(errorManager != NULL);
+    SkASSERT(cinfo != nullptr);
+    SkASSERT(errorManager != nullptr);
     cinfo->err = jpeg_std_error(errorManager);
     errorManager->error_exit = skjpeg_error_exit;
 }
 
 /**
  *  Common code for turning off upsampling and smoothing. Turning these
  *  off helps performance without showing noticable differences in the
  *  resulting bitmap.
  */
 static void turn_off_visual_optimizations(jpeg_decompress_struct* cinfo) {
-    SkASSERT(cinfo != NULL);
+    SkASSERT(cinfo != nullptr);
     /* this gives about 30% performance improvement. In theory it may
        reduce the visual quality, in practice I'm not seeing a difference
      */
     cinfo->do_fancy_upsampling = 0;
 
     /* this gives another few percents */
     cinfo->do_block_smoothing = 0;
 }
 
 /**
  * Common code for setting the dct method.
  */
 static void set_dct_method(const SkImageDecoder& decoder, jpeg_decompress_struct* cinfo) {
-    SkASSERT(cinfo != NULL);
+    SkASSERT(cinfo != nullptr);
 #ifdef DCT_IFAST_SUPPORTED
     if (decoder.getPreferQualityOverSpeed()) {
         cinfo->dct_method = JDCT_ISLOW;
     } else {
         cinfo->dct_method = JDCT_IFAST;
     }
 #else
     cinfo->dct_method = JDCT_ISLOW;
 #endif
 }
 
 SkColorType SkJPEGImageDecoder::getBitmapColorType(jpeg_decompress_struct* cinfo) {
-    SkASSERT(cinfo != NULL);
+    SkASSERT(cinfo != nullptr);
 
     SrcDepth srcDepth = k32Bit_SrcDepth;
     if (JCS_GRAYSCALE == cinfo->jpeg_color_space) {
         srcDepth = k8BitGray_SrcDepth;
     }
 
     SkColorType colorType = this->getPrefColorType(srcDepth, /*hasAlpha*/ false);
     switch (colorType) {
         case kAlpha_8_SkColorType:
             // Only respect A8 colortype if the original is grayscale,
@@ skipping 39 matching lines @@
     return colorType;
 }
 
 /**
  *  Based on the colortype and dither mode, adjust out_color_space and
  *  dither_mode of cinfo. Only does work in ANDROID_RGB
  */
 static void adjust_out_color_space_and_dither(jpeg_decompress_struct* cinfo,
                                               SkColorType colorType,
                                               const SkImageDecoder& decoder) {
-    SkASSERT(cinfo != NULL);
+    SkASSERT(cinfo != nullptr);
 #ifdef ANDROID_RGB
     cinfo->dither_mode = JDITHER_NONE;
     if (JCS_CMYK == cinfo->out_color_space) {
         return;
     }
     switch (colorType) {
         case kN32_SkColorType:
             cinfo->out_color_space = JCS_RGBA_8888;
             break;
         case kRGB_565_SkColorType:
@@ skipping 19 matching lines @@
     canvas.drawColor(SK_ColorWHITE);
 }
 
 /**
  *  Get the config and bytes per pixel of the source data. Return
  *  whether the data is supported.
  */
 static bool get_src_config(const jpeg_decompress_struct& cinfo,
                            SkScaledBitmapSampler::SrcConfig* sc,
                            int* srcBytesPerPixel) {
-    SkASSERT(sc != NULL && srcBytesPerPixel != NULL);
+    SkASSERT(sc != nullptr && srcBytesPerPixel != nullptr);
     if (JCS_CMYK == cinfo.out_color_space) {
         // In this case we will manually convert the CMYK values to RGB
         *sc = SkScaledBitmapSampler::kRGBX;
         // The CMYK work-around relies on 4 components per pixel here
         *srcBytesPerPixel = 4;
     } else if (3 == cinfo.out_color_components && JCS_RGB == cinfo.out_color_space) {
         *sc = SkScaledBitmapSampler::kRGB;
         *srcBytesPerPixel = 3;
 #ifdef ANDROID_RGB
     } else if (JCS_RGBA_8888 == cinfo.out_color_space) {
@@ skipping 102 matching lines @@
     SkScaledBitmapSampler sampler(cinfo.output_width, cinfo.output_height, sampleSize);
     // Assume an A8 bitmap is not opaque to avoid the check of each
     // individual pixel. It is very unlikely to be opaque, since
     // an opaque A8 bitmap would not be very interesting.
     // Otherwise, a jpeg image is opaque.
     bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
                                   colorType, alphaType));
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return kSuccess;
     }
-    if (!this->allocPixelRef(bm, NULL)) {
+    if (!this->allocPixelRef(bm, nullptr)) {
         return return_failure(cinfo, *bm, "allocPixelRef");
     }
 
     SkAutoLockPixels alp(*bm);
 
 #ifdef ANDROID_RGB
     /* short-circuit the SkScaledBitmapSampler when possible, as this gives
        a significant performance boost.
     */
     if (sampleSize == 1 &&
@@ skipping 275 matching lines @@
         return false;
     }
 
     if (!output_raw_data(cinfo, planes, rowBytes)) {
         return return_false(cinfo, "output_raw_data");
     }
 
     update_components_sizes(cinfo, componentSizes, kActualSize_SizeType);
     jpeg_finish_decompress(&cinfo);
 
-    if (NULL != colorSpace) {
+    if (nullptr != colorSpace) {
         *colorSpace = kJPEG_SkYUVColorSpace;
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_BUILD_FOR_ANDROID
 bool SkJPEGImageDecoder::onBuildTileIndex(SkStreamRewindable* stream, int *width, int *height) {
@@ skipping 53 matching lines @@
         *height = fImageHeight;
     }
 
     delete fImageIndex;
     fImageIndex = imageIndex.detach();
 
     return true;
 }
 
 bool SkJPEGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) {
-    if (NULL == fImageIndex) {
+    if (nullptr == fImageIndex) {
         return false;
     }
     jpeg_decompress_struct* cinfo = fImageIndex->cinfo();
 
     SkIRect rect = SkIRect::MakeWH(fImageWidth, fImageHeight);
     if (!rect.intersect(region)) {
         // If the requested region is entirely outside the image return false
         return false;
     }
 
@@ skipping 38 matching lines @@
     // 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() / actualSampleSize;
     int h = rect.height() / actualSampleSize;
     bool swapOnly = (rect == region) && bm->isNull() &&
                     (w == bitmap.width()) && (h == bitmap.height()) &&
                     ((startX - rect.x()) / actualSampleSize == 0) &&
                     ((startY - rect.y()) / actualSampleSize == 0);
     if (swapOnly) {
-        if (!this->allocPixelRef(&bitmap, NULL)) {
+        if (!this->allocPixelRef(&bitmap, nullptr)) {
             return return_false(*cinfo, bitmap, "allocPixelRef");
         }
     } else {
         if (!bitmap.tryAllocPixels()) {
             return return_false(*cinfo, bitmap, "allocPixels");
         }
     }
 
     SkAutoLockPixels alp(bitmap);
 
@@ skipping 249 matching lines @@
     switch (bm.colorType()) {
         case kN32_SkColorType:
             return Write_32_YUV;
         case kRGB_565_SkColorType:
             return Write_16_YUV;
         case kARGB_4444_SkColorType:
             return Write_4444_YUV;
         case kIndex_8_SkColorType:
             return Write_Index_YUV;
         default:
-            return NULL;
+            return nullptr;
     }
 }
 
 class SkJPEGImageEncoder : public SkImageEncoder {
 protected:
     virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) {
 #ifdef TIME_ENCODE
         SkAutoTime atm("JPEG Encode");
 #endif
 
         SkAutoLockPixels alp(bm);
-        if (NULL == bm.getPixels()) {
+        if (nullptr == bm.getPixels()) {
             return false;
         }
 
         jpeg_compress_struct    cinfo;
         skjpeg_error_mgr        sk_err;
         skjpeg_destination_mgr  sk_wstream(stream);
 
         // allocate these before set call setjmp
         SkAutoMalloc    oneRow;
 
         cinfo.err = jpeg_std_error(&sk_err);
         sk_err.error_exit = skjpeg_error_exit;
         if (setjmp(sk_err.fJmpBuf)) {
             return false;
         }
 
         // Keep after setjmp or mark volatile.
         const WriteScanline writer = ChooseWriter(bm);
-        if (NULL == writer) {
+        if (nullptr == writer) {
             return false;
         }
 
         jpeg_create_compress(&cinfo);
         cinfo.dest = &sk_wstream;
         cinfo.image_width = bm.width();
         cinfo.image_height = bm.height();
         cinfo.input_components = 3;
 #ifdef WE_CONVERT_TO_YUV
         cinfo.in_color_space = JCS_YCbCr;
 #else
         cinfo.in_color_space = JCS_RGB;
 #endif
         cinfo.input_gamma = 1;
 
         jpeg_set_defaults(&cinfo);
         jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
 #ifdef DCT_IFAST_SUPPORTED
         cinfo.dct_method = JDCT_IFAST;
 #endif
 
         jpeg_start_compress(&cinfo, TRUE);
 
         const int       width = bm.width();
         uint8_t*        oneRowP = (uint8_t*)oneRow.reset(width * 3);
 
-        const SkPMColor* colors = bm.getColorTable() ? bm.getColorTable()->readColors() : NULL;
+        const SkPMColor* colors = bm.getColorTable() ? bm.getColorTable()->readColors() : nullptr;
         const void*      srcRow = bm.getPixels();
 
         while (cinfo.next_scanline < cinfo.image_height) {
             JSAMPROW row_pointer[1];    /* pointer to JSAMPLE row[s] */
 
             writer(oneRowP, srcRow, width, colors);
             row_pointer[0] = oneRowP;
             (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
             srcRow = (const void*)((const char*)srcRow + bm.rowBytes());
         }
@@ skipping 24 matching lines @@
         return false;
     }
     return true;
 }
 
 
 static SkImageDecoder* sk_libjpeg_dfactory(SkStreamRewindable* stream) {
     if (is_jpeg(stream)) {
         return new SkJPEGImageDecoder;
     }
-    return NULL;
+    return nullptr;
 }
 
 static SkImageDecoder::Format get_format_jpeg(SkStreamRewindable* stream) {
     if (is_jpeg(stream)) {
         return SkImageDecoder::kJPEG_Format;
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageEncoder* sk_libjpeg_efactory(SkImageEncoder::Type t) {
-    return (SkImageEncoder::kJPEG_Type == t) ? new SkJPEGImageEncoder : NULL;
+    return (SkImageEncoder::kJPEG_Type == t) ? new SkJPEGImageEncoder : nullptr;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libjpeg_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_jpeg);
 static SkImageEncoder_EncodeReg gEReg(sk_libjpeg_efactory);