pdfviewer: add indexed rbg image support, enhanche caching(setData) for SkPdfObject

experimental/PdfViewer/SkPdfRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkDevice.h"
 #include "SkForceLinking.h"
@@ skipping 417 matching lines @@
     if (grayColortable == NULL) {
         SkPMColor* colors = new SkPMColor[256];
         for (int i = 0 ; i < 256; i++) {
             colors[i] = SkPreMultiplyARGB(255, i, i, i);
         }
         grayColortable = new SkColorTable(colors, 256);
     }
     return grayColortable;
 }
 
-static SkBitmap transferImageStreamToBitmap(const unsigned char* uncompressedStream, size_t uncompressedStreamLength,
+static SkBitmap* transferImageStreamToBitmap(const unsigned char* uncompressedStream, size_t uncompressedStreamLength,
                                      int width, int height, int bytesPerLine,
                                      int bpc, const std::string& colorSpace,
                                      bool transparencyMask) {
-    SkBitmap bitmap;
+    SkBitmap* bitmap = new SkBitmap();
 
     //int components = GetColorSpaceComponents(colorSpace);
 //#define MAX_COMPONENTS 10
 
     // TODO(edisonn): assume start of lines are aligned at 32 bits?
     // Is there a faster way to load the uncompressed stream into a bitmap?
 
     // minimal support for now
     if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) {
         SkColor* uncompressedStreamArgb = (SkColor*)malloc(width * height * sizeof(SkColor));
 
         for (int h = 0 ; h < height; h++) {
             long i = width * (h);
             for (int w = 0 ; w < width; w++) {
                 uncompressedStreamArgb[i] = SkColorSetRGB(uncompressedStream[3 * w],
                                                           uncompressedStream[3 * w + 1],
                                                           uncompressedStream[3 * w + 2]);
                 i++;
             }
             uncompressedStream += bytesPerLine;
         }
 
-        bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
-        bitmap.setPixels(uncompressedStreamArgb);
+        bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height);
+        bitmap->setPixels(uncompressedStreamArgb);
     }
     else if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) {
         unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height);
 
         for (int h = 0 ; h < height; h++) {
             long i = width * (h);
             for (int w = 0 ; w < width; w++) {
                 uncompressedStreamA8[i] = transparencyMask ? 255 - uncompressedStream[w] :
                                                              uncompressedStream[w];
                 i++;
             }
             uncompressedStream += bytesPerLine;
         }
 
-        bitmap.setConfig(transparencyMask ? SkBitmap::kA8_Config : SkBitmap::kIndex8_Config,
+        bitmap->setConfig(transparencyMask ? SkBitmap::kA8_Config : SkBitmap::kIndex8_Config,
                          width, height);
-        bitmap.setPixels(uncompressedStreamA8, transparencyMask ? NULL : getGrayColortable());
+        bitmap->setPixels(uncompressedStreamA8, transparencyMask ? NULL : getGrayColortable());
     }
 
     // TODO(edisonn): Report Warning, NYI, or error
     return bitmap;
 }
 
 // utils
 
 // TODO(edisonn): add cache, or put the bitmap property directly on the PdfObject
 // TODO(edisonn): deal with colorSpaces, we could add them to SkBitmap::Config
 // TODO(edisonn): preserve A1 format that skia knows, + fast convert from 111, 222, 444 to closest
 // skia format, through a table
 
 // this functions returns the image, it does not look at the smask.
 
-static SkBitmap getImageFromObject(PdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
+static SkBitmap* getImageFromObjectCore(PdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
     if (image == NULL || !image->hasStream()) {
         // TODO(edisonn): report warning to be used in testing.
-        return SkBitmap();
+        return NULL;
     }
 
     int64_t bpc = image->BitsPerComponent(pdfContext->fPdfDoc);
     int64_t width = image->Width(pdfContext->fPdfDoc);
     int64_t height = image->Height(pdfContext->fPdfDoc);
     std::string colorSpace = "DeviceRGB";
 
+    bool indexed = false;
+    SkPMColor colors[256];
+    int cnt = 0;
+
     // TODO(edisonn): color space can be an array too!
     if (image->isColorSpaceAName(pdfContext->fPdfDoc)) {
         colorSpace = image->getColorSpaceAsName(pdfContext->fPdfDoc);
+    } else if (image->isColorSpaceAArray(pdfContext->fPdfDoc)) {
+        SkPdfArray* array = image->getColorSpaceAsArray(pdfContext->fPdfDoc);
+        if (array && array->size() == 4 && array->objAtAIndex(0)->isName("Indexed") &&
+                                           (array->objAtAIndex(1)->isName("DeviceRGB") || array->objAtAIndex(1)->isName("RGB")) &&
+                                           array->objAtAIndex(2)->isInteger() &&
+                                           array->objAtAIndex(3)->isHexString()
+                                           ) {
+            // TODO(edisonn): suport only DeviceRGB for now.
+            indexed = true;
+            cnt = array->objAtAIndex(2)->intValue() + 1;
+            if (cnt > 256) {
+                // TODO(edionn): report NYIs
+                return NULL;
+            }
+            SkColorTable colorTable(cnt);
+            NotOwnedString data = array->objAtAIndex(3)->strRef();
+            if (data.fBytes != (unsigned int)cnt * 3) {
+                // TODO(edionn): report error/warning
+                return NULL;
+            }
+            for (int i = 0 ; i < cnt; i++) {
+                colors[i] = SkPreMultiplyARGB(0xff, data.fBuffer[3 * i], data.fBuffer[3 * i + 1], data.fBuffer[3 * i + 2]);
+            }
+        }
     }
 
 /*
     bool imageMask = image->imageMask();
 
     if (imageMask) {
         if (bpc != 0 && bpc != 1) {
             // TODO(edisonn): report warning to be used in testing.
             return SkBitmap();
         }
         bpc = 1;
     }
 */
 
     const unsigned char* uncompressedStream = NULL;
     size_t uncompressedStreamLength = 0;
 
     SkPdfStream* stream = (SkPdfStream*)image;
 
     if (!stream || !stream->GetFilteredStreamRef(&uncompressedStream, &uncompressedStreamLength) ||
             uncompressedStream == NULL || uncompressedStreamLength == 0) {
         // TODO(edisonn): report warning to be used in testing.
-        return SkBitmap();
+        return NULL;
     }
 
     SkPdfStreamCommonDictionary* streamDict = (SkPdfStreamCommonDictionary*)stream;
 
     if (streamDict->has_Filter() && ((streamDict->isFilterAName(NULL) &&
                                           streamDict->getFilterAsName(NULL) == "DCTDecode") ||
                                      (streamDict->isFilterAArray(NULL) &&
                                           streamDict->getFilterAsArray(NULL)->size() > 0 &&
                                           streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->isName() &&
                                           streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->nameValue2() == "DCTDecode"))) {
-        SkBitmap bitmap;
-        SkImageDecoder::DecodeMemory(uncompressedStream, uncompressedStreamLength, &bitmap);
+        SkBitmap* bitmap = new SkBitmap();
+        SkImageDecoder::DecodeMemory(uncompressedStream, uncompressedStreamLength, bitmap);
         return bitmap;
     }
 
 
 
     // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ...
 //    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
 //                                              obj.GetDictionary().GetKey(PdfName("Filter")));
 //    if (value && value->IsArray() && value->GetArray().GetSize() == 1) {
 //        value = resolveReferenceObject(pdfContext->fPdfDoc,
 //                                       &value->GetArray()[0]);
 //    }
 //    if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") {
 //        SkStream stream = SkStream::
 //        SkImageDecoder::Factory()
 //    }
 
+    // TODO(edisonn): assumes RGB for now, since it is the only onwe implemented
+    if (indexed) {
+        SkBitmap* bitmap = new SkBitmap();
+        bitmap->setConfig(SkBitmap::kIndex8_Config, width, height);
+        SkColorTable* colorTable = new SkColorTable(colors, cnt);
+        bitmap->setPixels((void*)uncompressedStream, colorTable);
+        return bitmap;
+    }
+
     int bytesPerLine = (int)(uncompressedStreamLength / height);
 #ifdef PDF_TRACE
     if (uncompressedStreamLength % height != 0) {
         printf("Warning uncompressedStreamLength modulo height != 0 !!!\n");
     }
 #endif
 
-    SkBitmap bitmap = transferImageStreamToBitmap(
+    SkBitmap* bitmap = transferImageStreamToBitmap(
             (unsigned char*)uncompressedStream, uncompressedStreamLength,
             (int)width, (int)height, bytesPerLine,
             (int)bpc, colorSpace,
             transparencyMask);
 
     return bitmap;
 }
 
-static SkBitmap getSmaskFromObject(PdfContext* pdfContext, SkPdfImageDictionary* obj) {
+static SkBitmap* getImageFromObject(PdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
+    if (!transparencyMask) {
+        if (!image->hasData(SkPdfObject::kBitmap_Data)) {
+            SkBitmap* bitmap = getImageFromObjectCore(pdfContext, image, transparencyMask);
+            image->setData(bitmap, SkPdfObject::kBitmap_Data);
+        }
+        return (SkBitmap*) image->data(SkPdfObject::kBitmap_Data);
+    } else {
+        return getImageFromObjectCore(pdfContext, image, transparencyMask);
+    }
+}
+
+static SkBitmap* getSmaskFromObject(PdfContext* pdfContext, SkPdfImageDictionary* obj) {
     SkPdfImageDictionary* sMask = obj->SMask(pdfContext->fPdfDoc);
 
     if (sMask) {
         return getImageFromObject(pdfContext, sMask, true);
     }
 
     // TODO(edisonn): implement GS SMask. Default to empty right now.
     return pdfContext->fGraphicsState.fSMask;
 }
 
 static PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, SkPdfImageDictionary* skpdfimage) {
     if (skpdfimage == NULL) {
         return kIgnoreError_PdfResult;
     }
 
-    SkBitmap image = getImageFromObject(pdfContext, skpdfimage, false);
-    SkBitmap sMask = getSmaskFromObject(pdfContext, skpdfimage);
+    SkBitmap* image = getImageFromObject(pdfContext, skpdfimage, false);
+    SkBitmap* sMask = getSmaskFromObject(pdfContext, skpdfimage);
 
     canvas->save();
     canvas->setMatrix(pdfContext->fGraphicsState.fCTM);
 
 #if 1
     SkScalar z = SkIntToScalar(0);
     SkScalar one = SkIntToScalar(1);
 
     SkPoint from[4] = {SkPoint::Make(z, z), SkPoint::Make(one, z), SkPoint::Make(one, one), SkPoint::Make(z, one)};
     SkPoint to[4] = {SkPoint::Make(z, one), SkPoint::Make(one, one), SkPoint::Make(one, z), SkPoint::Make(z, z)};
     SkMatrix flip;
     SkAssertResult(flip.setPolyToPoly(from, to, 4));
     SkMatrix solveImageFlip = pdfContext->fGraphicsState.fCTM;
     solveImageFlip.preConcat(flip);
     canvas->setMatrix(solveImageFlip);
 #endif
 
     SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
 
     // TODO(edisonn): soft mask type? alpha/luminosity.
-    if (sMask.empty()) {
-        canvas->drawBitmapRect(image, dst, NULL);
+    if (!sMask || sMask->empty()) {
+        canvas->drawBitmapRect(*image, dst, NULL);
     } else {
         canvas->saveLayer(&dst, NULL);
-        canvas->drawBitmapRect(image, dst, NULL);
+        canvas->drawBitmapRect(*image, dst, NULL);
         SkPaint xfer;
         pdfContext->fGraphicsState.applyGraphicsState(&xfer, false);
         // TODO(edisonn): is the blend mode specified already implicitly/explicitly in pdf?
         xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode
-        canvas->drawBitmapRect(sMask, dst, &xfer);
+        canvas->drawBitmapRect(*sMask, dst, &xfer);
         canvas->restore();
     }
 
     canvas->restore();
 
     return kPartial_PdfResult;
 }
 
 //TODO(edisonn): options for implementing isolation and knockout
 // 1) emulate them (current solution)
@@ skipping 609 matching lines @@
                     path.setFillType(SkPath::kEvenOdd_FillType);
                 }
                 canvas->clipPath(path);
 
                 if (pdfContext->fPdfDoc->mapper()->mapType1PatternDictionary(pdfContext->fGraphicsState.fNonStroking.fPattern) != kNone_SkPdfObjectType) {
                     SkPdfType1PatternDictionary* pattern = (SkPdfType1PatternDictionary*)pdfContext->fGraphicsState.fNonStroking.fPattern;
 
                     // TODO(edisonn): constants
                     // TODO(edisonn): colored
                     if (pattern->PaintType(pdfContext->fPdfDoc) == 1) {
-                        int xStep = (int)pattern->XStep(pdfContext->fPdfDoc);
-                        int yStep = (int)pattern->YStep(pdfContext->fPdfDoc);
+                        // TODO(edisonn): don't use abs, iterate as asked, if the cells intersect
+                        // it will change the result iterating in reverse
+                        int xStep = abs((int)pattern->XStep(pdfContext->fPdfDoc));
+                        int yStep = abs((int)pattern->YStep(pdfContext->fPdfDoc));
 
                         SkRect bounds = path.getBounds();
+
+                        // TODO(edisonn): xstep and ystep can be negative, and we need to iterate in reverse
+                        // TODO(edisonn): don't do that!
+                        bounds.sort();
+
                         SkScalar x;
                         SkScalar y;
 
-                        // TODO(edisonn): xstep and ystep can be negative, and we need to iterate in reverse
-
                         y = bounds.top();
                         int totalx = 0;
                         int totaly = 0;
                         while (y < bounds.bottom()) {
                             x = bounds.left();
                             totalx = 0;
 
                             while (x < bounds.right()) {
                                 doXObject(pdfContext, canvas, pattern);
 
@@ skipping 677 matching lines @@
         SkPdfSoftMaskImageDictionary* smid = (SkPdfSoftMaskImageDictionary*)sMask;
         pdfContext->fGraphicsState.fSMask = getImageFromObject(pdfContext, smid, true);
     } else {
         // TODO (edisonn): report error/warning
     }
 }
 
 void skpdfGraphicsStateApplySMask_name(PdfContext* pdfContext, const std::string& sMask) {
     if (sMask == "None") {
         pdfContext->fGraphicsState.fSoftMaskDictionary = NULL;
-        pdfContext->fGraphicsState.fSMask = SkBitmap();
+        pdfContext->fGraphicsState.fSMask = NULL;
         return;
     }
 
     //Next, get the ExtGState Dictionary from the Resource Dictionary:
     SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfDoc);
 
     if (extGStateDictionary == NULL) {
 #ifdef PDF_TRACE
         printf("ExtGState is NULL!\n");
 #endif
         // TODO (edisonn): report error/warning
         return;
     }
 
     SkPdfObject* obj = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(sMask.c_str()));
     if (!obj || !obj->isDictionary()) {
         // TODO (edisonn): report error/warning
         return;
     }
 
     pdfContext->fGraphicsState.fSoftMaskDictionary = NULL;
-    pdfContext->fGraphicsState.fSMask = SkBitmap();
+    pdfContext->fGraphicsState.fSMask = NULL;
 
     skpdfGraphicsStateApplySMask_dict(pdfContext, obj->asDictionary());
 }
 
 void skpdfGraphicsStateApplyAIS(PdfContext* pdfContext, bool alphaSource) {
     pdfContext->fGraphicsState.fAlphaSource = alphaSource;
 }
 
 
 //dictName gs (PDF 1.2) Set the specified parameters in the graphics state. dictName is
@@ skipping 575 matching lines @@
 
     rect = SkRect::MakeWH(width, height);
 
     setup_bitmap(output, (int)SkScalarToDouble(width), (int)SkScalarToDouble(height));
 
     SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (*output)));
     SkCanvas canvas(device);
 
     return renderer.renderPage(page, &canvas, rect);
 }