Code generator for dinamic generation of podofo wrappers

experimental/PdfViewer/pdf_viewer_main.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 "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 #include "SkTArray.h"
 #include "picture_utils.h"
 
 #include <iostream>
 #include <cstdio>
 #include <stack>
 
 #include "podofo.h"
+using namespace PoDoFo;
+
+bool LongFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        long* data);
+
+bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        bool* data);
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        std::string* data);
+
+
+
+#include "pdf_auto_gen.h"
 
 /*
  * TODO(edisonn): ASAP so skp -> pdf -> png looks greap
  * - load gs/ especially smask and already known prop
  * - use transparency (I think ca and CA ops)
  * - load font for baidu.pdf
  * - load font for youtube.pdf
 */
 
-//#define PDF_TRACE
+#define PDF_TRACE
 //#define PDF_TRACE_DIFF_IN_PNG
 //#define PDF_DEBUG_NO_CLIPING
 //#define PDF_DEBUG_NO_PAGE_CLIPING
 //#define PDF_DEBUG_3X
 
 // TODO(edisonn): move in trace util.
 #ifdef PDF_TRACE
 static void SkTraceMatrix(const SkMatrix& matrix, const char* sz = "") {
     printf("SkMatrix %s ", sz);
     for (int i = 0 ; i < 9 ; i++) {
@@ skipping 26 matching lines @@
         return 1;
     } else if (colorSpace == "DeviceRGB" ||
             colorSpace == "CalRGB" ||
             colorSpace == "Lab") {
         return 3;
     } else {
         return 0;
     }
 }
 
-PdfObject* resolveReferenceObject(PdfMemDocument* pdfDoc,
-                                        PdfObject* obj,
-                                        bool resolveOneElementArrays = false) {
+const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
+                                  const PdfObject* obj,
+                                  bool resolveOneElementArrays = false) {
     while (obj && (obj->IsReference() || (resolveOneElementArrays &&
                                           obj->IsArray() &&
                                           obj->GetArray().GetSize() == 1))) {
         if (obj->IsReference()) {
             // We need to force the non const, the only update we will do is for recurssion checks.
             PdfReference& ref = (PdfReference&)obj->GetReference();
             obj = pdfDoc->GetObjects().GetObject(ref);
         } else {
             obj = &obj->GetArray()[0];
         }
@@ skipping 51 matching lines @@
     SkPath              fClipPath;
 
     PdfColorOperator    fStroking;
     PdfColorOperator    fNonStroking;
 
     double              fLineWidth;
     double              fTextLeading;
     double              fWordSpace;
     double              fCharSpace;
 
-    PdfObject*          fObjectWithResources;
+    const PdfObject*    fObjectWithResources;
 
     SkBitmap            fSMask;
 
     PdfGraphicsState() {
         fCurPosX      = 0.0;
         fCurPosY      = 0.0;
         fCurFontSize  = 0.0;
         fTextBlock    = false;
         fCurFont      = NULL;
         fMatrix       = SkMatrix::I();
@@ skipping 389 matching lines @@
 
 // TODO(edisonn): move this code in podofo, so we don't have to fix the font.
 // This logic needs to be moved in PdfEncodingObjectFactory::CreateEncoding
 std::map<PdfFont*, PdfCMapEncoding*> gFontsFixed;
 PdfEncoding* FixPdfFont(PdfContext* pdfContext, PdfFont* fCurFont) {
     // TODO(edisonn): and is Identity-H
     if (gFontsFixed.find(fCurFont) == gFontsFixed.end()) {
         if (fCurFont->GetObject()->IsDictionary() && fCurFont->GetObject()->GetDictionary().HasKey(PdfName("ToUnicode"))) {
             PdfCMapEncoding* enc = new PdfCMapEncoding(
                     fCurFont->GetObject(),
-                    resolveReferenceObject(pdfContext->fPdfDoc,
+                    (PdfObject*)resolveReferenceObject(pdfContext->fPdfDoc,
                                            fCurFont->GetObject()->GetDictionary().GetKey(PdfName("ToUnicode"))),
                     PdfCMapEncoding::eBaseEncoding_Identity);  // todo, read the base encoding
             gFontsFixed[fCurFont] = enc;
             return enc;
         }
 
         return NULL;
     }
 
     return gFontsFixed[fCurFont];
@@ skipping 145 matching lines @@
 }
 
 // TODO(edisonn): create header files with declarations!
 PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
 PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
 PdfResult PdfOp_Tw(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
 PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper);
 
 // TODO(edisonn): deal with synonyms (/BPC == /BitsPerComponent), here or in GetKey?
 // Always pass long form in key, and have a map of long -> short key
-bool LongFromDictionary(PdfContext* pdfContext,
-                        PdfDictionary& dict,
+bool LongFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
                         const char* key,
                         long* data) {
-    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
-                                                    dict.GetKey(PdfName(key)));
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsNumber()) {
         return false;
     }
 
     *data = value->GetNumber();
     return true;
 }
 
-bool BoolFromDictionary(PdfContext* pdfContext,
-                        PdfDictionary& dict,
+bool LongFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        long* data) {
+    if (LongFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return LongFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
                         const char* key,
                         bool* data) {
-    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
-                                                    dict.GetKey(PdfName(key)));
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsBool()) {
         return false;
     }
 
     *data = value->GetBool();
     return true;
 }
 
-bool NameFromDictionary(PdfContext* pdfContext,
-                        PdfDictionary& dict,
+bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        bool* data) {
+    if (BoolFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return BoolFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool NameFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
                         const char* key,
                         std::string* data) {
-    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
-                                                    dict.GetKey(PdfName(key)),
-                                                    true);
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
     if (value == NULL || !value->IsName()) {
         return false;
     }
 
     *data = value->GetName().GetName();
     return true;
 }
 
+bool NameFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        std::string* data) {
+    if (NameFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return NameFromDictionary(pdfDoc, dict, abr, data);
+}
+
 // TODO(edisonn): perf!!!
 
 static SkColorTable* getGrayColortable() {
     static SkColorTable* grayColortable = NULL;
     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);
@@ skipping 106 matching lines @@
 
 // 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.
 
-SkBitmap getImageFromObject(PdfContext* pdfContext, PdfObject& obj, bool transparencyMask) {
+SkBitmap getImageFromObject(PdfContext* pdfContext, const SkPdfImage* image, bool transparencyMask) {
+    if (image == NULL || !image->valid()) {
+        // TODO(edisonn): report warning to be used in testing.
+        return SkBitmap();
+    }
+
+    // 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()
+//    }
+
+    long bpc = image->bpc();
+    long width = image->w();
+    long height = image->h();
+    std::string colorSpace = image->cs();
+
+/*
+    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 PdfObject* obj = image->podofo();
+
+    char* uncompressedStream = NULL;
+    pdf_long uncompressedStreamLength = 0;
+
+    PdfResult ret = kPartial_PdfResult;
+    // TODO(edisonn): get rid of try/catch exceptions! We should not throw on user data!
+    try {
+        obj->GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
+    } catch (PdfError& e) {
+        // TODO(edisonn): report warning to be used in testing.
+        return SkBitmap();
+    }
+
+    int bytesPerLine = uncompressedStreamLength / height;
+#ifdef PDF_TRACE
+    if (uncompressedStreamLength % height != 0) {
+        printf("Warning uncompressedStreamLength % height != 0 !!!\n");
+    }
+#endif
+
+    SkBitmap bitmap = transferImageStreamToBitmap(
+            (unsigned char*)uncompressedStream, uncompressedStreamLength,
+            width, height, bytesPerLine,
+            bpc, colorSpace,
+            transparencyMask);
+
+    free(uncompressedStream);
+
+    return bitmap;
+}
+
+SkBitmap getImageFromObjectOld(PdfContext* pdfContext, const PdfObject& obj, bool transparencyMask) {
     if (!obj.HasStream() || obj.GetStream() == NULL || obj.GetStream()->GetLength() == 0 ||
         !obj.IsDictionary()) {
         // TODO(edisonn): report warning to be used in testing.
         return SkBitmap();
     }
 
-    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
+    const 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]);
     }
 
     // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ...
 //    if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") {
 //        SkStream stream = SkStream::
 //        SkImageDecoder::Factory()
 //    }
 
     // Get color space
     // translate
 
     long bpc = 0;
-    LongFromDictionary(pdfContext, obj.GetDictionary(), "BitsPerComponent", &bpc);
+    LongFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "BitsPerComponent", "BPC", &bpc);
 
     bool imageMask = false;
-    BoolFromDictionary(pdfContext, obj.GetDictionary(), "ImageMask", &imageMask);
+    BoolFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "ImageMask", "", &imageMask);
 
     if (imageMask) {
         if (bpc != 0 && bpc != 1) {
             // TODO(edisonn): report warning to be used in testing.
             return SkBitmap();
         }
         bpc = 1;
     }
 
     long width;
-    if (!LongFromDictionary(pdfContext, obj.GetDictionary(), "Width", &width)) {
+    if (!LongFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "Width", &width)) {
         // TODO(edisonn): report warning to be used in testing.
         return SkBitmap();
     }
 
     long height;
-    if (!LongFromDictionary(pdfContext, obj.GetDictionary(), "Height", &height)) {
+    if (!LongFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "Height", &height)) {
         // TODO(edisonn): report warning to be used in testing.
         return SkBitmap();
     }
 
     std::string colorSpace;  // TODO(edisonn): load others than names, for more complicated
-    if (!NameFromDictionary(pdfContext, obj.GetDictionary(), "ColorSpace", &colorSpace)) {
+    if (!NameFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "ColorSpace", &colorSpace)) {
         // TODO(edisonn): report warning to be used in testing.
         return SkBitmap();
     }
 
     char* uncompressedStream = NULL;
     pdf_long uncompressedStreamLength = 0;
 
     PdfResult ret = kPartial_PdfResult;
     // TODO(edisonn): get rid of try/catch exceptions! We should not throw on user data!
     try {
@@ skipping 14 matching lines @@
             (unsigned char*)uncompressedStream, uncompressedStreamLength,
             width, height, bytesPerLine,
             bpc, colorSpace,
             transparencyMask);
 
     free(uncompressedStream);
 
     return bitmap;
 }
 
-SkBitmap getSmaskFromObject(PdfContext* pdfContext, PdfObject& obj) {
-    PdfObject* sMask = resolveReferenceObject(pdfContext->fPdfDoc,
+SkBitmap getSmaskFromObject(PdfContext* pdfContext, const SkPdfImage* obj) {
+    const PdfObject* sMask = resolveReferenceObject(pdfContext->fPdfDoc,
+                                              obj->podofo()->GetDictionary().GetKey(PdfName("SMask")));
+
+#ifdef PDF_TRACE
+    std::string str;
+    if (sMask) {
+        sMask->ToString(str);
+        printf("/SMask of /Subtype /Image: %s\n", str.c_str());
+    }
+#endif
+
+    if (sMask) {
+        SkPdfImage skxobjmask(pdfContext->fPdfDoc, sMask);
+        return getImageFromObject(pdfContext, &skxobjmask, true);
+    }
+
+    // TODO(edisonn): implement GS SMask. Default to empty right now.
+    return pdfContext->fGraphicsState.fSMask;
+}
+
+SkBitmap getSmaskFromObjectOld(PdfContext* pdfContext, const PdfObject& obj) {
+    const PdfObject* sMask = resolveReferenceObject(pdfContext->fPdfDoc,
                                               obj.GetDictionary().GetKey(PdfName("SMask")));
 
 #ifdef PDF_TRACE
     std::string str;
     if (sMask) {
         sMask->ToString(str);
         printf("/SMask of /Subtype /Image: %s\n", str.c_str());
     }
 #endif
 
     if (sMask) {
-        return getImageFromObject(pdfContext, *sMask, true);
+        return getImageFromObjectOld(pdfContext, *sMask, true);
     }
 
     // TODO(edisonn): implement GS SMask. Default to empty right now.
     return pdfContext->fGraphicsState.fSMask;
 }
 
-PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, PdfObject& obj) {
+
+PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfImage* skpdfimage) {
+    if (skpdfimage == NULL || !skpdfimage->valid()) {
+        return kIgnoreError_PdfResult;
+    }
+
+    SkBitmap image = getImageFromObject(pdfContext, skpdfimage, false);
+    SkBitmap sMask = getSmaskFromObject(pdfContext, skpdfimage);
+
+    canvas->save();
+    canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
+    SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
+
+    if (sMask.empty()) {
+        canvas->drawBitmapRect(image, dst, NULL);
+    } else {
+        canvas->saveLayer(&dst, NULL);
+        canvas->drawBitmapRect(image, dst, NULL);
+        SkPaint xfer;
+        xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode
+        canvas->drawBitmapRect(sMask, dst, &xfer);
+        canvas->restore();
+    }
+
+    canvas->restore();
+
+    return kPartial_PdfResult;
+}
+
+PdfResult doXObject_ImageOld(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
     if (!obj.HasStream() || obj.GetStream() == NULL || obj.GetStream()->GetLength() == 0 ||
         !obj.IsDictionary()) {
         return kIgnoreError_PdfResult;
     }
 
-    SkBitmap image = getImageFromObject(pdfContext, obj, false);
-    SkBitmap sMask = getSmaskFromObject(pdfContext, obj);
+    SkBitmap image = getImageFromObjectOld(pdfContext, obj, false);
+    SkBitmap sMask = getSmaskFromObjectOld(pdfContext, obj);
 
     canvas->save();
     canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
     SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
 
     if (sMask.empty()) {
         canvas->drawBitmapRect(image, dst, NULL);
     } else {
         canvas->saveLayer(&dst, NULL);
         canvas->drawBitmapRect(image, dst, NULL);
         SkPaint xfer;
         xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode
         canvas->drawBitmapRect(sMask, dst, &xfer);
         canvas->restore();
     }
 
     canvas->restore();
 
     return kPartial_PdfResult;
 }
 
-PdfResult doXObject_ImageOld(PdfContext* pdfContext, SkCanvas* canvas, PdfObject& obj) {
+
+PdfResult doXObject_ImageOld2(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
     if (!obj.HasStream() || obj.GetStream() == NULL || obj.GetStream()->GetLength() == 0 ||
         !obj.IsDictionary()) {
         return kIgnoreError_PdfResult;
     }
 
-    PdfObject* sMask = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* sMask = resolveReferenceObject(pdfContext->fPdfDoc,
                                               obj.GetDictionary().GetKey(PdfName("SMask")));
     // TODO(edisonn): else get smask from graphi state
     // TODO(edisonn): add utility, SkBitmap loadBitmap(PdfObject& obj, bool no_smask);
     // TODO(edisonn): add utility, SkBitmap loadSmask(state, PdfObject& obj);
 
 #ifdef PDF_TRACE
     std::string str;
     if (sMask) {
         sMask->ToString(str);
         printf("/SMask of /Subtype /Image: %s\n", str.c_str());
     }
 #endif
 
+/*
+    // 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]);
     }
 
-    // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ...
-//    if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") {
-//        SkStream stream = SkStream::
-//        SkImageDecoder::Factory()
-//    }
-
+    if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") {
+        SkStream stream = SkStream::
+        SkImageDecoder::Factory()
+    }
+*/
     // Get color space
     // trasnlate
 
     long bpc = 0;
-    LongFromDictionary(pdfContext, obj.GetDictionary(), "BitsPerComponent", &bpc);
+    LongFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "BitsPerComponent", "BPC", &bpc);
 
     bool imageMask = false;
-    BoolFromDictionary(pdfContext, obj.GetDictionary(), "ImageMask", &imageMask);
+    BoolFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "ImageMask", "", &imageMask);
 
     if (imageMask) {
         if (bpc != 0 && bpc != 1) {
             return kIgnoreError_PdfResult;
         }
         bpc = 1;
     }
 
     long width;
-    if (!LongFromDictionary(pdfContext, obj.GetDictionary(), "Width", &width)) {
+    if (!LongFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "Width", "W", &width)) {
         return kIgnoreError_PdfResult;
     }
 
     long height;
-    if (!LongFromDictionary(pdfContext, obj.GetDictionary(), "Height", &height)) {
+    if (!LongFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "Height", "H", &height)) {
         return kIgnoreError_PdfResult;
     }
 
     std::string colorSpace;  // TODO(edisonn): load others than names, for more complicated
-    if (!NameFromDictionary(pdfContext, obj.GetDictionary(), "ColorSpace", &colorSpace)) {
+    if (!NameFromDictionary(pdfContext->fPdfDoc, obj.GetDictionary(), "ColorSpace", "", &colorSpace)) {
         return kIgnoreError_PdfResult;
     }
 
     char* uncompressedStream = NULL;
     pdf_long uncompressedStreamLength = 0;
 
     PdfResult ret = kPartial_PdfResult;
     // TODO(edisonn): get rid of try/catch exceptions! We should not throw on user data!
     try {
         obj.GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
@@ skipping 30 matching lines @@
     canvas->save();
     canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
     SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
     canvas->drawBitmapRect(bitmap, dst, NULL);
     canvas->restore();
 
     return kPartial_PdfResult;
 }
 
 bool SkMatrixFromDictionary(PdfContext* pdfContext,
-                            PdfDictionary& dict,
+                            const PdfDictionary& dict,
                             const char* key,
                             SkMatrix* matrix) {
-    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
                                                     dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsArray()) {
         return false;
     }
 
     if (value->GetArray().GetSize() != 6) {
         return false;
     }
 
     double array[6];
     for (int i = 0; i < 6; i++) {
-        PdfObject* elem = resolveReferenceObject(pdfContext->fPdfDoc, &value->GetArray()[i]);
+        const PdfObject* elem = resolveReferenceObject(pdfContext->fPdfDoc, &value->GetArray()[i]);
         if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
             return false;
         }
         array[i] = elem->GetReal();
     }
 
     *matrix = SkMatrixFromPdfMatrix(array);
     return true;
 }
 
 bool SkRectFromDictionary(PdfContext* pdfContext,
-                          PdfDictionary& dict,
+                          const PdfDictionary& dict,
                           const char* key,
                           SkRect* rect) {
-    PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc,
                                                     dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsArray()) {
         return false;
     }
 
     if (value->GetArray().GetSize() != 4) {
         return false;
     }
 
     double array[4];
     for (int i = 0; i < 4; i++) {
-        PdfObject* elem = resolveReferenceObject(pdfContext->fPdfDoc, &value->GetArray()[i]);
+        const PdfObject* elem = resolveReferenceObject(pdfContext->fPdfDoc, &value->GetArray()[i]);
         if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
             return false;
         }
         array[i] = elem->GetReal();
     }
 
     *rect = SkRect::MakeLTRB(SkDoubleToScalar(array[0]),
                              SkDoubleToScalar(array[1]),
                              SkDoubleToScalar(array[2]),
                              SkDoubleToScalar(array[3]));
     return true;
 }
 
-PdfResult doXObject_Form(PdfContext* pdfContext, SkCanvas* canvas, PdfObject& obj) {
+PdfResult doXObject_Form(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
     if (!obj.HasStream() || obj.GetStream() == NULL || obj.GetStream()->GetLength() == 0) {
         return kOK_PdfResult;
     }
 
     PdfOp_q(pdfContext, canvas, NULL);
     canvas->save();
 
     pdfContext->fGraphicsState.fObjectWithResources = &obj;
 
     SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Current matrix");
@@ skipping 36 matching lines @@
         ret = kIgnoreError_PdfResult;
     }
 
     // TODO(edisonn): should we restore the variable stack at the same state?
     // There could be operands left, that could be consumed by a parent tokenizer when we pop.
     canvas->restore();
     PdfOp_Q(pdfContext, canvas, NULL);
     return ret;
 }
 
-PdfResult doXObject_PS(PdfContext* pdfContext, SkCanvas* canvas, PdfObject& obj) {
+PdfResult doXObject_PS(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
     return kNYI_PdfResult;
 }
 
 // TODO(edisonn): faster, have the property on the PdfObject itself.
-std::set<PdfObject*> gInRendering;
+std::set<const PdfObject*> gInRendering;
 
 class CheckRecursiveRendering {
-    PdfObject& fObj;
+    const PdfObject& fObj;
 public:
-    CheckRecursiveRendering(PdfObject& obj) : fObj(obj) {
+    CheckRecursiveRendering(const PdfObject& obj) : fObj(obj) {
         gInRendering.insert(&obj);
     }
 
     ~CheckRecursiveRendering() {
         //SkASSERT(fObj.fInRendering);
         gInRendering.erase(&fObj);
     }
 
-    static bool IsInRendering(PdfObject& obj) {
+    static bool IsInRendering(const PdfObject& obj) {
         return gInRendering.find(&obj) != gInRendering.end();
     }
 };
 
-PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, PdfObject& obj) {
+PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
     if (CheckRecursiveRendering::IsInRendering(obj)) {
         // Oops, corrupt PDF!
         return kIgnoreError_PdfResult;
     }
 
     CheckRecursiveRendering checkRecursion(obj);
 
+    // TODO(edisonn): check type
+    SkPdfObject* skobj = NULL;
+    if (!PodofoMapper::mapObject(*pdfContext->fPdfDoc, obj, &skobj)) return kIgnoreError_PdfResult;
+
+    if (!skobj || !skobj->valid()) return kIgnoreError_PdfResult;
+
+    PdfResult ret = kIgnoreError_PdfResult;
+    switch (skobj->getType())
+    {
+        case kObjectDictionaryXObjectImage_SkPdfObjectType:
+            ret = doXObject_Image(pdfContext, canvas, skobj->asImage());
+        //case kObjectDictionaryXObjectForm_SkPdfObjectType:
+            //return doXObject_Form(skxobj.asForm());
+        //case kObjectDictionaryXObjectPS_SkPdfObjectType:
+            //return doXObject_PS(skxobj.asPS());
+    }
+
+    delete skobj;
+    return ret;
+}
+
+PdfResult doXObjectOld(PdfContext* pdfContext, SkCanvas* canvas, const PdfObject& obj) {
+    if (CheckRecursiveRendering::IsInRendering(obj)) {
+        // Oops, corrupt PDF!
+        return kIgnoreError_PdfResult;
+    }
+
+    CheckRecursiveRendering checkRecursion(obj);
+
     if (!obj.IsDictionary()) {
         return kIgnoreError_PdfResult;
     }
 
-    PdfObject* type = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* type = resolveReferenceObject(pdfContext->fPdfDoc,
                                                    obj.GetDictionary().GetKey(PdfName("Type")));
 
     if (type == NULL || !type->IsName()) {
         return kIgnoreError_PdfResult;
     }
 
     if (type->GetName().GetName() != "XObject") {
         return kIgnoreError_PdfResult;
     }
 
-    PdfObject* subtype =
+    const PdfObject* subtype =
             resolveReferenceObject(pdfContext->fPdfDoc,
                                    obj.GetDictionary().GetKey(PdfName("Subtype")));
 
     if (subtype == NULL || !subtype->IsName()) {
         return kIgnoreError_PdfResult;
     }
 
     if (subtype->GetName().GetName() == "Image") {
-        return doXObject_Image(pdfContext, canvas, obj);
+        return doXObject_ImageOld(pdfContext, canvas, obj);
     } else if (subtype->GetName().GetName() == "Form") {
         return doXObject_Form(pdfContext, canvas, obj);
     } else if (subtype->GetName().GetName() == "PS") {
         return doXObject_PS(pdfContext, canvas, obj);
     }
     return kIgnoreError_PdfResult;
 }
 
 PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fStateStack.push(pdfContext->fGraphicsState);
@@ skipping 720 matching lines @@
     pdfContext->fVarStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //dictName gs (PDF 1.2) Set the specified parameters in the graphics state. dictName is
 //the name of a graphics state parameter dictionary in the ExtGState subdictionary of the current resource dictionary (see the next section).
 PdfResult PdfOp_gs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     PdfName name = pdfContext->fVarStack.top().GetName();    pdfContext->fVarStack.pop();
 
-    PdfDictionary& pageDict = pdfContext->fGraphicsState.fObjectWithResources->GetDictionary();
-    PdfObject* resources = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfDictionary& pageDict = pdfContext->fGraphicsState.fObjectWithResources->GetDictionary();
+    const PdfObject* resources = resolveReferenceObject(pdfContext->fPdfDoc,
                                                         pageDict.GetKey("Resources"));
 
     if (resources == NULL) {
 #ifdef PDF_TRACE
         printf("WARNING: No Resources for a page with 'gs' operator!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
 #ifdef PDF_TRACE
     std::string str;
     resources->ToString(str);
     printf("Print gs Page Resources: %s\n", str.c_str());
 #endif
 
     if (!resources->IsDictionary()) {
 #ifdef PDF_TRACE
         printf("Resources is not a dictionary!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
-    PdfDictionary& resourceDict = resources->GetDictionary();
+    const PdfDictionary& resourceDict = resources->GetDictionary();
     //Next, get the ExtGState Dictionary from the Resource Dictionary:
-    PdfObject* extGStateDictionary = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* extGStateDictionary = resolveReferenceObject(pdfContext->fPdfDoc,
                                                                 resourceDict.GetKey("ExtGState"));
 
     if (extGStateDictionary == NULL) {
 #ifdef PDF_TRACE
         printf("ExtGState is NULL!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
     if (!extGStateDictionary->IsDictionary()) {
 #ifdef PDF_TRACE
         printf("extGStateDictionary is not a dictionary!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
-    PdfObject* value =
+    const PdfObject* value =
             resolveReferenceObject(pdfContext->fPdfDoc,
                                    extGStateDictionary->GetDictionary().GetKey(name));
 
     if (value == NULL) {
 #ifdef PDF_TRACE
         printf("Named object not found!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
@@ skipping 78 matching lines @@
 PdfResult PdfOp_sh(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fVarStack.pop();
 
     return kNYI_PdfResult;
 }
 
 //name Do
 PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     PdfName name = pdfContext->fVarStack.top().GetName();    pdfContext->fVarStack.pop();
 
-    PdfDictionary& pageDict = pdfContext->fGraphicsState.fObjectWithResources->GetDictionary();
-    PdfObject* resources = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfDictionary& pageDict = pdfContext->fGraphicsState.fObjectWithResources->GetDictionary();
+    const PdfObject* resources = resolveReferenceObject(pdfContext->fPdfDoc,
                                                         pageDict.GetKey("Resources"));
 
     if (resources == NULL) {
 #ifdef PDF_TRACE
         printf("WARNING: No Resources for a page with 'Do' operator!s\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
 #ifdef PDF_TRACE
     std::string str;
     resources->ToString(str);
     printf("Print Do Page Resources: %s\n", str.c_str());
 #endif
 
     if (!resources->IsDictionary()) {
 #ifdef PDF_TRACE
         printf("Resources is not a dictionary!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
-    PdfDictionary& resourceDict = resources->GetDictionary();
+    const PdfDictionary& resourceDict = resources->GetDictionary();
     //Next, get the XObject Dictionary from the Resource Dictionary:
-    PdfObject* xObjectDictionary = resolveReferenceObject(pdfContext->fPdfDoc,
+    const PdfObject* xObjectDictionary = resolveReferenceObject(pdfContext->fPdfDoc,
                                                                 resourceDict.GetKey("XObject"));
 
     if (xObjectDictionary == NULL) {
 #ifdef PDF_TRACE
         printf("XObject is NULL!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
     if (!xObjectDictionary->IsDictionary()) {
 #ifdef PDF_TRACE
         printf("xObjectDictionary is not a dictionary!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
-    PdfObject* value =
+    const PdfObject* value =
             resolveReferenceObject(pdfContext->fPdfDoc,
                                    xObjectDictionary->GetDictionary().GetKey(name));
 
     if (value == NULL) {
 #ifdef PDF_TRACE
         printf("Named object not found!\n");
 #endif
         return kIgnoreError_PdfResult;
     }
 
@@ skipping 606 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif