Use a wrapper for SkDebugf in SkCodec.

src/codec/SkCodec_libbmp.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec_libbmp.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 121 matching lines @@
     // The size of the second (info) header in bytes
     uint32_t infoBytes;
 
     // Bmps embedded in Icos skip the first Bmp header
     if (!isIco) {
         // Read the first header and the size of the second header
         SkAutoTDeleteArray<uint8_t> hBuffer(
                 SkNEW_ARRAY(uint8_t, kBmpHeaderBytesPlusFour));
         if (stream->read(hBuffer.get(), kBmpHeaderBytesPlusFour) !=
                 kBmpHeaderBytesPlusFour) {
-            SkDebugf("Error: unable to read first bitmap header.\n");
+            SkCodecPrintf("Error: unable to read first bitmap header.\n");
             return NULL;
         }
 
         totalBytes = get_int(hBuffer.get(), 2);
         offset = get_int(hBuffer.get(), 10);
         if (offset < kBmpHeaderBytes + kBmpOS2V1Bytes) {
-            SkDebugf("Error: invalid starting location for pixel data\n");
+            SkCodecPrintf("Error: invalid starting location for pixel data\n");
             return NULL;
         }
 
         // The size of the second (info) header in bytes
         // The size is the first field of the second header, so we have already
         // read the first four infoBytes.
         infoBytes = get_int(hBuffer.get(), 14);
         if (infoBytes < kBmpOS2V1Bytes) {
-            SkDebugf("Error: invalid second header size.\n");
+            SkCodecPrintf("Error: invalid second header size.\n");
             return NULL;
         }
     } else {
         // This value is only used by RLE compression.  Bmp in Ico files do not
         // use RLE.  If the compression field is incorrectly signaled as RLE,
         // we will catch this and signal an error below.
         totalBytes = 0;
 
         // Bmps in Ico cannot specify an offset.  We will always assume that
         // pixel data begins immediately after the color table.  This value
         // will be corrected below.
         offset = 0;
 
         // Read the size of the second header
         SkAutoTDeleteArray<uint8_t> hBuffer(
                 SkNEW_ARRAY(uint8_t, 4));
         if (stream->read(hBuffer.get(), 4) != 4) {
-            SkDebugf("Error: unable to read size of second bitmap header.\n");
+            SkCodecPrintf("Error: unable to read size of second bitmap header.\n");
             return NULL;
         }
         infoBytes = get_int(hBuffer.get(), 0);
         if (infoBytes < kBmpOS2V1Bytes) {
-            SkDebugf("Error: invalid second header size.\n");
+            SkCodecPrintf("Error: invalid second header size.\n");
             return NULL;
         }
     }
 
     // We already read the first four bytes of the info header to get the size
     const uint32_t infoBytesRemaining = infoBytes - 4;
 
     // Read the second header
     SkAutoTDeleteArray<uint8_t> iBuffer(
             SkNEW_ARRAY(uint8_t, infoBytesRemaining));
     if (stream->read(iBuffer.get(), infoBytesRemaining) != infoBytesRemaining) {
-        SkDebugf("Error: unable to read second bitmap header.\n");
+        SkCodecPrintf("Error: unable to read second bitmap header.\n");
         return NULL;
     }
 
     // The number of bits used per pixel in the pixel data
     uint16_t bitsPerPixel;
 
     // The compression method for the pixel data
     uint32_t compression = kNone_BitmapCompressionMethod;
 
     // Number of colors in the color table, defaults to 0 or max (see below)
@@ skipping 37 matching lines @@
             case 60:
             case kBmpOS2V2Bytes:
                 headerType = kOS2VX_BitmapHeaderType;
                 break;
             default:
                 // We do not signal an error here because there is the
                 // possibility of new or undocumented bmp header types.  Most
                 // of the newer versions of bmp headers are similar to and
                 // build off of the older versions, so we may still be able to
                 // decode the bmp.
-                SkDebugf("Warning: unknown bmp header format.\n");
+                SkCodecPrintf("Warning: unknown bmp header format.\n");
                 headerType = kUnknown_BitmapHeaderType;
                 break;
         }
         // We check the size of the header before entering the if statement.
         // We should not reach this point unless the size is large enough for
         // these required fields.
         SkASSERT(infoBytesRemaining >= 12);
         width = get_int(iBuffer.get(), 0);
         height = get_int(iBuffer.get(), 4);
         bitsPerPixel = get_short(iBuffer.get(), 10);
@@ skipping 12 matching lines @@
         bytesPerColor = 4;
     } else if (infoBytes >= kBmpOS2V1Bytes) {
         // The OS2V1 is treated separately because it has a unique format
         headerType = kOS2V1_BitmapHeaderType;
         width = (int) get_short(iBuffer.get(), 0);
         height = (int) get_short(iBuffer.get(), 2);
         bitsPerPixel = get_short(iBuffer.get(), 6);
         bytesPerColor = 3;
     } else {
         // There are no valid bmp headers
-        SkDebugf("Error: second bitmap header size is invalid.\n");
+        SkCodecPrintf("Error: second bitmap header size is invalid.\n");
         return NULL;
     }
 
     // Check for valid dimensions from header
     RowOrder rowOrder = kBottomUp_RowOrder;
     if (height < 0) {
         height = -height;
         rowOrder = kTopDown_RowOrder;
     }
     // The height field for bmp in ico is double the actual height because they
     // contain an XOR mask followed by an AND mask
     if (isIco) {
         height /= 2;
     }
     static const int kBmpMaxDim = 1 << 16;
     if (width < 0 || width >= kBmpMaxDim || height >= kBmpMaxDim) {
         // TODO: Decide if we want to support really large bmps.
-        SkDebugf("Error: invalid bitmap dimensions.\n");
+        SkCodecPrintf("Error: invalid bitmap dimensions.\n");
         return NULL;
     }
 
     // Create mask struct
     SkMasks::InputMasks inputMasks;
     memset(&inputMasks, 0, sizeof(SkMasks::InputMasks));
 
     // Determine the input compression format and set bit masks if necessary
     uint32_t maskBytes = 0;
     BitmapInputFormat inputFormat = kUnknown_BitmapInputFormat;
     switch (compression) {
         case kNone_BitmapCompressionMethod:
             inputFormat = kStandard_BitmapInputFormat;
             break;
         case k8BitRLE_BitmapCompressionMethod:
             if (bitsPerPixel != 8) {
-                SkDebugf("Warning: correcting invalid bitmap format.\n");
+                SkCodecPrintf("Warning: correcting invalid bitmap format.\n");
                 bitsPerPixel = 8;
             }
             inputFormat = kRLE_BitmapInputFormat;
             break;
         case k4BitRLE_BitmapCompressionMethod:
             if (bitsPerPixel != 4) {
-                SkDebugf("Warning: correcting invalid bitmap format.\n");
+                SkCodecPrintf("Warning: correcting invalid bitmap format.\n");
                 bitsPerPixel = 4;
             }
             inputFormat = kRLE_BitmapInputFormat;
             break;
         case kAlphaBitMasks_BitmapCompressionMethod:
         case kBitMasks_BitmapCompressionMethod:
             // Load the masks
             inputFormat = kBitMask_BitmapInputFormat;
             switch (headerType) {
                 case kInfoV1_BitmapHeaderType: {
                     // The V1 header stores the bit masks after the header
                     SkAutoTDeleteArray<uint8_t> mBuffer(
                             SkNEW_ARRAY(uint8_t, kBmpMaskBytes));
                     if (stream->read(mBuffer.get(), kBmpMaskBytes) !=
                             kBmpMaskBytes) {
-                        SkDebugf("Error: unable to read bit inputMasks.\n");
+                        SkCodecPrintf("Error: unable to read bit inputMasks.\n");
                         return NULL;
                     }
                     maskBytes = kBmpMaskBytes;
                     inputMasks.red = get_int(mBuffer.get(), 0);
                     inputMasks.green = get_int(mBuffer.get(), 4);
                     inputMasks.blue = get_int(mBuffer.get(), 8);
                     break;
                 }
                 case kInfoV2_BitmapHeaderType:
                 case kInfoV3_BitmapHeaderType:
                 case kInfoV4_BitmapHeaderType:
                 case kInfoV5_BitmapHeaderType:
                     // Header types are matched based on size.  If the header
                     // is V2+, we are guaranteed to be able to read at least
                     // this size.
                     SkASSERT(infoBytesRemaining >= 48);
                     inputMasks.red = get_int(iBuffer.get(), 36);
                     inputMasks.green = get_int(iBuffer.get(), 40);
                     inputMasks.blue = get_int(iBuffer.get(), 44);
                     break;
                 case kOS2VX_BitmapHeaderType:
                     // TODO: Decide if we intend to support this.
                     //       It is unsupported in the previous version and
                     //       in chromium.  I have not come across a test case
                     //       that uses this format.
-                    SkDebugf("Error: huffman format unsupported.\n");
+                    SkCodecPrintf("Error: huffman format unsupported.\n");
                     return NULL;
                 default:
-                   SkDebugf("Error: invalid bmp bit masks header.\n");
+                   SkCodecPrintf("Error: invalid bmp bit masks header.\n");
                    return NULL;
             }
             break;
         case kJpeg_BitmapCompressionMethod:
             if (24 == bitsPerPixel) {
                 inputFormat = kRLE_BitmapInputFormat;
                 break;
             }
             // Fall through
         case kPng_BitmapCompressionMethod:
             // TODO: Decide if we intend to support this.
             //       It is unsupported in the previous version and
             //       in chromium.  I think it is used mostly for printers.
-            SkDebugf("Error: compression format not supported.\n");
+            SkCodecPrintf("Error: compression format not supported.\n");
             return NULL;
         case kCMYK_BitmapCompressionMethod:
         case kCMYK8BitRLE_BitmapCompressionMethod:
         case kCMYK4BitRLE_BitmapCompressionMethod:
             // TODO: Same as above.
-            SkDebugf("Error: CMYK not supported for bitmap decoding.\n");
+            SkCodecPrintf("Error: CMYK not supported for bitmap decoding.\n");
             return NULL;
         default:
-            SkDebugf("Error: invalid format for bitmap decoding.\n");
+            SkCodecPrintf("Error: invalid format for bitmap decoding.\n");
             return NULL;
     }
 
     // Most versions of bmps should be rendered as opaque.  Either they do
     // not have an alpha channel, or they expect the alpha channel to be
     // ignored.  V3+ bmp files introduce an alpha mask and allow the creator
     // of the image to use the alpha channels.  However, many of these images
     // leave the alpha channel blank and expect to be rendered as opaque.  This
     // is the case for almost all V3 images, so we render these as opaque.  For
     // V4+, we will use the alpha channel, and fix the image later if it turns
@@ skipping 34 matching lines @@
             }
             break;
         case 1:
         case 2:
         case 4:
         case 8:
         case 24:
         case 32:
             break;
         default:
-            SkDebugf("Error: invalid input value for bits per pixel.\n");
+            SkCodecPrintf("Error: invalid input value for bits per pixel.\n");
             return NULL;
     }
 
     // Check that input bit masks are valid and create the masks object
     SkAutoTDelete<SkMasks>
             masks(SkMasks::CreateMasks(inputMasks, bitsPerPixel));
     if (NULL == masks) {
-        SkDebugf("Error: invalid input masks.\n");
+        SkCodecPrintf("Error: invalid input masks.\n");
         return NULL;
     }
 
     // Check for a valid number of total bytes when in RLE mode
     if (totalBytes <= offset && kRLE_BitmapInputFormat == inputFormat) {
-        SkDebugf("Error: RLE requires valid input size.\n");
+        SkCodecPrintf("Error: RLE requires valid input size.\n");
         return NULL;
     }
     const size_t RLEBytes = totalBytes - offset;
 
     // Calculate the number of bytes read so far
     const uint32_t bytesRead = kBmpHeaderBytes + infoBytes + maskBytes;
     if (!isIco && offset < bytesRead) {
-        SkDebugf("Error: pixel data offset less than header size.\n");
+        SkCodecPrintf("Error: pixel data offset less than header size.\n");
         return NULL;
     }
 
     // Return the codec
     // We will use ImageInfo to store width, height, and alpha type.  We will
     // set color type to kN32_SkColorType because that should be the default
     // output.
     const SkImageInfo& imageInfo = SkImageInfo::Make(width, height,
             kN32_SkColorType, alphaType);
     return SkNEW_ARGS(SkBmpCodec, (imageInfo, stream, bitsPerPixel,
@@ skipping 34 matching lines @@
  */
 SkCodec::Result SkBmpCodec::onGetPixels(const SkImageInfo& dstInfo,
                                         void* dst, size_t dstRowBytes,
                                         const Options&,
                                         SkPMColor*, int*) {
     // Check for proper input and output formats
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
-        SkDebugf("Error: scaling not supported.\n");
+        SkCodecPrintf("Error: scaling not supported.\n");
         return kInvalidScale;
     }
     if (!conversion_possible(dstInfo, this->getInfo())) {
-        SkDebugf("Error: cannot convert input type to output type.\n");
+        SkCodecPrintf("Error: cannot convert input type to output type.\n");
         return kInvalidConversion;
     }
 
     // Create the color table if necessary and prepare the stream for decode
     if (!createColorTable(dstInfo.alphaType())) {
-        SkDebugf("Error: could not create color table.\n");
+        SkCodecPrintf("Error: could not create color table.\n");
         return kInvalidInput;
     }
 
     // Perform the decode
     switch (fInputFormat) {
         case kBitMask_BitmapInputFormat:
             return decodeMask(dstInfo, dst, dstRowBytes);
         case kRLE_BitmapInputFormat:
             return decodeRLE(dstInfo, dst, dstRowBytes);
         case kStandard_BitmapInputFormat:
@@ skipping 19 matching lines @@
         // Also set fNumColors to maxColors when it is too large
         maxColors = 1 << fBitsPerPixel;
         if (fNumColors == 0 || fNumColors >= maxColors) {
             fNumColors = maxColors;
         }
 
         // Read the color table from the stream
         colorBytes = fNumColors * fBytesPerColor;
         SkAutoTDeleteArray<uint8_t> cBuffer(SkNEW_ARRAY(uint8_t, colorBytes));
         if (stream()->read(cBuffer.get(), colorBytes) != colorBytes) {
-            SkDebugf("Error: unable to read color table.\n");
+            SkCodecPrintf("Error: unable to read color table.\n");
             return false;
         }
 
         // Choose the proper packing function
         SkPMColor (*packARGB) (uint32_t, uint32_t, uint32_t, uint32_t);
         switch (alphaType) {
             case kOpaque_SkAlphaType:
             case kUnpremul_SkAlphaType:
                 packARGB = &SkPackARGB32NoCheck;
                 break;
@@ skipping 32 matching lines @@
     // Bmp-in-Ico files do not use an offset to indicate where the pixel data
     // begins.  Pixel data always begins immediately after the color table.
     if (!fIsIco) {
         // Check that we have not read past the pixel array offset
         if(fOffset < colorBytes) {
             // This may occur on OS 2.1 and other old versions where the color
             // table defaults to max size, and the bmp tries to use a smaller
             // color table.  This is invalid, and our decision is to indicate
             // an error, rather than try to guess the intended size of the
             // color table.
-            SkDebugf("Error: pixel data offset less than color table size.\n");
+            SkCodecPrintf("Error: pixel data offset less than color table size.\n");
             return false;
         }
 
         // After reading the color table, skip to the start of the pixel array
         if (stream()->skip(fOffset - colorBytes) != fOffset - colorBytes) {
-            SkDebugf("Error: unable to skip to image data.\n");
+            SkCodecPrintf("Error: unable to skip to image data.\n");
             return false;
         }
     }
 
     // Set the color table and return true on success
     fColorTable.reset(SkNEW_ARGS(SkColorTable, (colorTable, maxColors)));
     return true;
 }
 
 /*
@@ skipping 16 matching lines @@
     // Create the swizzler
     SkAutoTDelete<SkMaskSwizzler> maskSwizzler(
             SkMaskSwizzler::CreateMaskSwizzler(dstInfo, dst, dstRowBytes,
             fMasks, fBitsPerPixel));
 
     // Iterate over rows of the image
     bool transparent = true;
     for (int y = 0; y < height; y++) {
         // Read a row of the input
         if (stream()->read(srcRow, rowBytes) != rowBytes) {
-            SkDebugf("Warning: incomplete input stream.\n");
+            SkCodecPrintf("Warning: incomplete input stream.\n");
             return kIncompleteInput;
         }
 
         // Decode the row in destination format
         int row = kBottomUp_RowOrder == fRowOrder ? height - 1 - y : y;
         SkSwizzler::ResultAlpha r = maskSwizzler->next(srcRow, row);
         transparent &= SkSwizzler::IsTransparent(r);
 
         // Move to the next row
         srcRow = SkTAddOffset<uint8_t>(srcRow, rowBytes);
@@ skipping 117 matching lines @@
 
     // Set constant values
     const int width = dstInfo.width();
     const int height = dstInfo.height();
 
     // Input buffer parameters
     uint32_t currByte = 0;
     SkAutoTDeleteArray<uint8_t> buffer(SkNEW_ARRAY(uint8_t, fRLEBytes));
     size_t totalBytes = stream()->read(buffer.get(), fRLEBytes);
     if (totalBytes < fRLEBytes) {
-        SkDebugf("Warning: incomplete RLE file.\n");
+        SkCodecPrintf("Warning: incomplete RLE file.\n");
     } else if (totalBytes <= 0) {
-        SkDebugf("Error: could not read RLE image data.\n");
+        SkCodecPrintf("Error: could not read RLE image data.\n");
         return kInvalidInput;
     }
 
     // Destination parameters
     int x = 0;
     int y = 0;
     // If the code skips pixels, remaining pixels are transparent or black
     // TODO: Skip this if memory was already zeroed.
     memset(dst, 0, dstRowBytes * height);
     SkPMColor* dstPtr = (SkPMColor*) dst;
 
     while (true) {
         // Every entry takes at least two bytes
         if ((int) totalBytes - currByte < 2) {
-            SkDebugf("Warning: incomplete RLE input.\n");
+            SkCodecPrintf("Warning: incomplete RLE input.\n");
             return kIncompleteInput;
         }
 
         // Read the next two bytes.  These bytes have different meanings
         // depending on their values.  In the first interpretation, the first
         // byte is an escape flag and the second byte indicates what special
         // task to perform.
         const uint8_t flag = buffer.get()[currByte++];
         const uint8_t task = buffer.get()[currByte++];
 
         // If we have reached a row that is beyond the image size, and the RLE
         // code does not indicate end of file, abort and signal a warning.
         if (y >= height && (flag != RLE_ESCAPE || (task != RLE_EOF))) {
-            SkDebugf("Warning: invalid RLE input.\n");
+            SkCodecPrintf("Warning: invalid RLE input.\n");
             return kIncompleteInput;
         }
 
         // Perform decoding
         if (RLE_ESCAPE == flag) {
             switch (task) {
                 case RLE_EOL:
                     x = 0;
                     y++;
                     break;
                 case RLE_EOF:
                     return kSuccess;
                 case RLE_DELTA: {
                     // Two bytes are needed to specify delta
                     if ((int) totalBytes - currByte < 2) {
-                        SkDebugf("Warning: incomplete RLE input\n");
+                        SkCodecPrintf("Warning: incomplete RLE input\n");
                         return kIncompleteInput;
                     }
                     // Modify x and y
                     const uint8_t dx = buffer.get()[currByte++];
                     const uint8_t dy = buffer.get()[currByte++];
                     x += dx;
                     y += dy;
                     if (x > width || y > height) {
-                        SkDebugf("Warning: invalid RLE input.\n");
+                        SkCodecPrintf("Warning: invalid RLE input.\n");
                         return kIncompleteInput;
                     }
                     break;
                 }
                 default: {
                     // If task does not match any of the above signals, it
                     // indicates that we have a sequence of non-RLE pixels.
                     // Furthermore, the value of task is equal to the number
                     // of pixels to interpret.
                     uint8_t numPixels = task;
                     const size_t rowBytes = compute_row_bytes(numPixels,
                             fBitsPerPixel);
                     // Abort if setting numPixels moves us off the edge of the
                     // image.  Also abort if there are not enough bytes
                     // remaining in the stream to set numPixels.
                     if (x + numPixels > width ||
                             (int) totalBytes - currByte < SkAlign2(rowBytes)) {
-                        SkDebugf("Warning: invalid RLE input.\n");
+                        SkCodecPrintf("Warning: invalid RLE input.\n");
                         return kIncompleteInput;
                     }
                     // Set numPixels number of pixels
                     while (numPixels > 0) {
                         switch(fBitsPerPixel) {
                             case 4: {
                                 SkASSERT(currByte < totalBytes);
                                 uint8_t val = buffer.get()[currByte++];
                                 setRLEPixel(dstPtr, dstRowBytes, dstInfo, x++,
                                         y, val >> 4);
@@ skipping 36 matching lines @@
             // If the first byte read is not a flag, it indicates the number of
             // pixels to set in RLE mode.
             const uint8_t numPixels = flag;
             const int endX = SkTMin<int>(x + numPixels, width);
 
             if (24 == fBitsPerPixel) {
                 // In RLE24, the second byte read is part of the pixel color.
                 // There are two more required bytes to finish encoding the
                 // color.
                 if ((int) totalBytes - currByte < 2) {
-                    SkDebugf("Warning: incomplete RLE input\n");
+                    SkCodecPrintf("Warning: incomplete RLE input\n");
                     return kIncompleteInput;
                 }
 
                 // Fill the pixels up to endX with the specified color
                 uint8_t blue = task;
                 uint8_t green = buffer.get()[currByte++];
                 uint8_t red = buffer.get()[currByte++];
                 while (x < endX) {
                     setRLE24Pixel(dstPtr, dstRowBytes, dstInfo, x++, y, red,
                             green, blue);
@@ skipping 69 matching lines @@
             SkImageGenerator::kNo_ZeroInitialized));
 
     // Allocate space for a row buffer and a source for the swizzler
     SkAutoTDeleteArray<uint8_t> srcBuffer(SkNEW_ARRAY(uint8_t, rowBytes));
 
     // Iterate over rows of the image
     // FIXME: bool transparent = true;
     for (int y = 0; y < height; y++) {
         // Read a row of the input
         if (stream()->read(srcBuffer.get(), rowBytes) != rowBytes) {
-            SkDebugf("Warning: incomplete input stream.\n");
+            SkCodecPrintf("Warning: incomplete input stream.\n");
             return kIncompleteInput;
         }
 
         // Decode the row in destination format
         uint32_t row;
         if (kTopDown_RowOrder == fRowOrder) {
             row = y;
         } else {
             row = height - 1 - y;
         }
@@ skipping 31 matching lines @@
 
     // Finally, apply the AND mask for bmp-in-ico images
     if (fIsIco) {
         // The AND mask is always 1 bit per pixel
         const size_t rowBytes = SkAlign4(compute_row_bytes(width, 1));
 
         SkPMColor* dstPtr = (SkPMColor*) dst;
         for (int y = 0; y < height; y++) {
             // The srcBuffer will at least be large enough
             if (stream()->read(srcBuffer.get(), rowBytes) != rowBytes) {
-                SkDebugf("Warning: incomplete AND mask for bmp-in-ico.\n");
+                SkCodecPrintf("Warning: incomplete AND mask for bmp-in-ico.\n");
                 return kIncompleteInput;
             }
 
             int row;
             if (kBottomUp_RowOrder == fRowOrder) {
                 row = height - y - 1;
             } else {
                 row = y;
             }
 
             SkPMColor* dstRow =
                     SkTAddOffset<SkPMColor>(dstPtr, row * dstRowBytes);
 
             for (int x = 0; x < width; x++) {
                 int quotient;
                 int modulus;
                 SkTDivMod(x, 8, &quotient, &modulus);
                 uint32_t shift = 7 - modulus;
                 uint32_t alphaBit =
                         (srcBuffer.get()[quotient] >> shift) & 0x1;
                 dstRow[x] &= alphaBit - 1;
             }
         }
     }
 
     // Finished decoding the entire image
     return kSuccess;
 }