PDF: remove unused SkPDFDevice::setDCTEncoder()

src/pdf/SkPDFImage.cpp

 /*
  * Copyright 2010 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 "SkPDFImage.h"
 
 #include "SkBitmap.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkData.h"
 #include "SkFlate.h"
 #include "SkPDFBitmap.h"
 #include "SkPDFCatalog.h"
 #include "SkPixelRef.h"
 #include "SkRect.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkUnPreMultiply.h"
 
-static const int kNoColorTransform = 0;
-
 static size_t get_uncompressed_size(const SkBitmap& bitmap,
                                     const SkIRect& srcRect) {
     switch (bitmap.colorType()) {
         case kIndex_8_SkColorType:
             return srcRect.width() * srcRect.height();
         case kARGB_4444_SkColorType:
             return ((srcRect.width() * 3 + 1) / 2) * srcRect.height();
         case kRGB_565_SkColorType:
             return srcRect.width() * 3 * srcRect.height();
         case kRGBA_8888_SkColorType:
@@ skipping 415 matching lines @@
             SkASSERT(false);
     }
 
     outBitmap.setImmutable();
 
     return outBitmap;
 }
 
 // static
 SkPDFImage* SkPDFImage::CreateImage(const SkBitmap& bitmap,
-                                    const SkIRect& srcRect,
-                                    SkData* (*encoder)(size_t*, const SkBitmap&)) {
+                                    const SkIRect& srcRect) {
     if (bitmap.colorType() == kUnknown_SkColorType) {
         return NULL;
     }
 
     bool isTransparent = false;
     SkAutoTDelete<SkStream> alphaData;
     if (!bitmap.isOpaque()) {
         // Note that isOpaque is not guaranteed to return false for bitmaps
         // with alpha support but a completely opaque alpha channel,
         // so alphaData may still be NULL if we have a completely opaque
         // (or transparent) bitmap.
         alphaData.reset(
                 extract_image_data(bitmap, srcRect, true, &isTransparent));
     }
     if (isTransparent) {
         return NULL;
     }
 
     SkPDFImage* image;
     SkColorType colorType = bitmap.colorType();
     if (alphaData.get() != NULL && (kN32_SkColorType == colorType ||
                                     kARGB_4444_SkColorType == colorType)) {
         if (kN32_SkColorType == colorType) {
             image = SkNEW_ARGS(SkPDFImage, (NULL, bitmap, false,
                                             SkIRect::MakeWH(srcRect.width(),
-                                                            srcRect.height()),
-                                            encoder));
+                                                            srcRect.height())));
         } else {
             SkBitmap unpremulBitmap = unpremultiply_bitmap(bitmap, srcRect);
             image = SkNEW_ARGS(SkPDFImage, (NULL, unpremulBitmap, false,
                                             SkIRect::MakeWH(srcRect.width(),
-                                                            srcRect.height()),
-                                            encoder));
+                                                            srcRect.height())));
         }
     } else {
-        image = SkNEW_ARGS(SkPDFImage, (NULL, bitmap, false, srcRect, encoder));
+        image = SkNEW_ARGS(SkPDFImage, (NULL, bitmap, false, srcRect));
     }
     if (alphaData.get() != NULL) {
         SkAutoTUnref<SkPDFImage> mask(
-                SkNEW_ARGS(SkPDFImage, (alphaData.get(), bitmap,
-                                        true, srcRect, NULL)));
+                SkNEW_ARGS(SkPDFImage, (alphaData.get(), bitmap, true, srcRect)));
         image->insert("SMask", new SkPDFObjRef(mask))->unref();
     }
     return image;
 }
 
 SkPDFImage::~SkPDFImage() {}
 
 SkPDFImage::SkPDFImage(SkStream* stream,
                        const SkBitmap& bitmap,
                        bool isAlpha,
-                       const SkIRect& srcRect,
-                       SkData* (*encoder)(size_t*, const SkBitmap&))
+                       const SkIRect& srcRect)
     : fIsAlpha(isAlpha),
-      fSrcRect(srcRect),
-      fEncoder(encoder) {
+      fSrcRect(srcRect) {
 
     if (bitmap.isImmutable()) {
         fBitmap = bitmap;
     } else {
         bitmap.deepCopyTo(&fBitmap);
         fBitmap.setImmutable();
     }
 
     if (stream != NULL) {
         this->setData(stream);
@@ skipping 53 matching lines @@
         decodeValue->append(scale5Val.get());
         insert("Decode", decodeValue.get());
     }
 }
 
 SkPDFImage::SkPDFImage(SkPDFImage& pdfImage)
     : SkPDFStream(pdfImage),
       fBitmap(pdfImage.fBitmap),
       fIsAlpha(pdfImage.fIsAlpha),
       fSrcRect(pdfImage.fSrcRect),
-      fEncoder(pdfImage.fEncoder),
       fStreamValid(pdfImage.fStreamValid) {
     // Nothing to do here - the image params are already copied in SkPDFStream's
     // constructor, and the bitmap will be regenerated and encoded in
     // populate.
 }
 
 bool SkPDFImage::populate(SkPDFCatalog* catalog) {
     if (getState() == kUnused_State) {
         // Initializing image data for the first time.

[mtklein, 2015/02/20 03:36:13]

Do both these comments still make sense here?

[hal.canary, 2015/02/20 12:52:57]

Yes.  This class caches the Deflate-encoded data (via ->setData()).  I will
completely remove this class very soon (as soon as I teach SkPDFBitmap to handle
non-8888 bitmaps).

-        if (fEncoder && get_uncompressed_size(fBitmap, fSrcRect) > 1) {
-            SkBitmap subset;
-            // Extract subset
-            if (!fBitmap.extractSubset(&subset, fSrcRect)) {
-                return false;
-            }
-            size_t pixelRefOffset = 0;
-            SkAutoTUnref<SkData> data(fEncoder(&pixelRefOffset, subset));
-            if (data.get() && data->size() < get_uncompressed_size(fBitmap,
-                                                                   fSrcRect)) {
-                this->setData(data.get());
-
-                insertName("Filter", "DCTDecode");
-                insertInt("ColorTransform", kNoColorTransform);
-                insertInt("Length", this->dataSize());
-                setState(kCompressed_State);
-                return true;
-            }
-        }
         // Fallback method
         if (!fStreamValid) {
             SkAutoTDelete<SkStream> stream(
                     extract_image_data(fBitmap, fSrcRect, fIsAlpha, NULL));
             this->setData(stream);
             fStreamValid = true;
         }
         return INHERITED::populate(catalog);
     }
 #ifndef SK_NO_FLATE
     else if (getState() == kNoCompression_State) {
-#else  // SK_NO_FLATE
-    else if (getState() == kNoCompression_State && fEncoder) {
-#endif  // SK_NO_FLATE
         // Compression has not been requested when the stream was first created,
         // but the new catalog wants it compressed.
         if (!getSubstitute()) {
             SkPDFStream* substitute = SkNEW_ARGS(SkPDFImage, (*this));
             setSubstitute(substitute);
             catalog->setSubstitute(this, substitute);
         }
         return false;
     }
+#endif  // SK_NO_FLATE
     return true;
 }
 
 #if 0  // reenable when we can figure out the JPEG colorspace
 namespace {
 /**
  *  This PDFObject assumes that its constructor was handed
  *  Jpeg-encoded data that can be directly embedded into a PDF.
  */
 class PDFJPEGImage : public SkPDFObject {
@@ skipping 59 matching lines @@
     return ((0 == memcmp(data->bytes(), bytesZeroToThree,
                          sizeof(bytesZeroToThree)))
             && (0 == memcmp(data->bytes() + 6, bytesSixToTen,
                             sizeof(bytesSixToTen))));
 }
 }  // namespace
 #endif
 
 SkPDFObject* SkPDFCreateImageObject(
         const SkBitmap& bitmap,
-        const SkIRect& subset,
-        SkData* (*encoder)(size_t*, const SkBitmap&)) {
+        const SkIRect& subset) {
     if (SkPDFObject* pdfBitmap = SkPDFBitmap::Create(bitmap, subset)) {
         return pdfBitmap;
     }
 #if 0  // reenable when we can figure out the JPEG colorspace
     if (SkIRect::MakeWH(bitmap.width(), bitmap.height()) == subset) {
         SkAutoTUnref<SkData> encodedData(ref_encoded_data(bitmap));
         if (is_jfif_jpeg(encodedData)) {
             return SkNEW_ARGS(PDFJPEGImage,
                               (encodedData, bitmap.width(), bitmap.height()));
         }
     }
 #endif
-    return SkPDFImage::CreateImage(bitmap, subset, encoder);
+    return SkPDFImage::CreateImage(bitmap, subset);
 }