load font manually, for now Type0

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 "SkForceLinking.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;
 
+
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
+
+//#define PDF_TRACE
+//#define PDF_TRACE_DIFF_IN_PNG
+//#define PDF_DEBUG_NO_CLIPING
+//#define PDF_DEBUG_NO_PAGE_CLIPING
+//#define PDF_DEBUG_3X
+
+
 const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
                                   const PdfObject* obj,
                                   bool resolveOneElementArrays = false);
 
 bool LongFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         long* data);
 
@@ skipping 38 matching lines @@
 class SkPdfObject;
 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfObject** data);
 
 
 struct SkPdfFileSpec {};
 class SkPdfArray;
-struct SkPdfStream {};
+class SkPdfStream;
 struct SkPdfDate {};
 struct SkPdfTree {};
 struct SkPdfFunction {};
 
 bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfArray* data);
 
 
 bool FileSpecFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfFileSpec* data);
 
 
 bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
-                        SkPdfStream* data);
+                        SkPdfStream** data);
 
 bool TreeFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfTree** data);
 
 bool DateFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfDate* data);
 
 bool SkRectFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkRect* data);
 
 bool FunctionFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfFunction* data);
 
 
 #include "SkPdfHeaders_autogen.h"
 #include "SkPdfPodofoMapper_autogen.h"
 #include "SkPdfParser.h"
+#include "SkPdfFont.h"
+
+// TODO(edisonn): fix the mess with the files.
+#include "SkPdfFont.cpp"
 
 bool ArrayFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfArray* data) {return false;}
 
 bool FileSpecFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfFileSpec* data) {return false;}
 
 bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
-                        SkPdfStream* data) {return false;}
+                        SkPdfStream** data);
 
 bool TreeFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfTree** data) {return false;}
 
 bool DateFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfDate* data) {return false;}
 
 bool FunctionFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfFunction* data) {return false;}
 
 
 
 /*
  * TODO(edisonn):
- * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo ... in progress
- * - ASAP so skp -> pdf -> png looks great
- * - load gs/ especially smask and already known prop (skp)...
  * - all font types and all ppdf font features
  *      - word spacing
  *      - load font for baidu.pdf
  *      - load font for youtube.pdf
  *      - parser for pdf from the definition already available in pdfspec_autogen.py
+ *      - all docs from ~/work
+ * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo ... in progress
+ * - load gs/ especially smask and already known prop (skp) ... in progress
  * - wrapper on classes for customizations? e.g.
  * SkPdfPageObjectVanila - has only the basic loaders/getters
  * SkPdfPageObject : public SkPdfPageObjectVanila, extends, and I can add customizations here
  * need to find a nice object model for all this with constructors and factories
  * - deal with inheritable automatically ?
  * - deal with specific type in spec directly, add all dictionary types to known types
 */
 
-//#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++) {
         printf("%f ", SkScalarToDouble(matrix.get(i)));
     }
     printf("\n");
 }
@@ skipping 87 matching lines @@
     SkMatrix            fMatrix;
     SkMatrix            fMatrixTm;
     SkMatrix            fMatrixTlm;
 
     double              fCurPosX;
     double              fCurPosY;
 
     double              fCurFontSize;
     bool                fTextBlock;
     PdfFont*            fCurFont;
+    SkPdfFont*          fSkFont;
     SkPath              fPath;
     bool                fPathClosed;
 
     // Clip that is applied after the drawing is done!!!
     bool                fHasClipPathToApply;
     SkPath              fClipPath;
 
     PdfColorOperator    fStroking;
     PdfColorOperator    fNonStroking;
 
@@ skipping 15 matching lines @@
         fMatrix       = SkMatrix::I();
         fMatrixTm     = SkMatrix::I();
         fMatrixTlm    = SkMatrix::I();
         fPathClosed   = true;
         fLineWidth    = 0;
         fTextLeading  = 0;
         fWordSpace    = 0;
         fCharSpace    = 0;
         fHasClipPathToApply = false;
         fResources    = NULL;
+        fSkFont       = NULL;
     }
 
     void applyGraphicsState(SkPaint* paint, bool stroking) {
         if (stroking) {
             fStroking.applyGraphicsState(paint);
         } else {
             fNonStroking.applyGraphicsState(paint);
         }
 
         // TODO(edisonn): get this from pdfContext->options,
@@ skipping 53 matching lines @@
     if (*pdfOp == '\0') return false;
 
     char markedPdfOp[100] = ",";
     strcat(markedPdfOp, pdfOp);
     strcat(markedPdfOp, ",");
 
     return (strstr(allOpWithVisualEffects, markedPdfOp) != NULL);
 }
 
 // TODO(edisonn): Pass PdfContext and SkCanvasd only with the define for instrumentation.
-static bool readToken(SkPdfTokenizer fTokenizer, PdfToken* token) {
-    bool ret = fTokenizer.readToken(token);
+static bool readToken(SkPdfTokenizer* fTokenizer, PdfToken* token) {
+    bool ret = fTokenizer->readToken(token);
 
     gReadOp++;
 
 #ifdef PDF_TRACE_DIFF_IN_PNG
     // TODO(edisonn): compare with old bitmap, and save only new bits are available, and save
     // the numbar and name of last operation, so the file name will reflect op that changed.
     if (hasVisualEffect(gLastKeyword)) {  // TODO(edisonn): and has dirty bits.
         gDumpCanvas->flush();
 
         SkBitmap bitmap;
@@ skipping 73 matching lines @@
     }
 #endif
 
     return ret;
 }
 
 // TODO(edisonn): Document PdfTokenLooper and subclasses.
 class PdfTokenLooper {
 protected:
     PdfTokenLooper* fParent;
-    SkPdfTokenizer fTokenizer;
+    SkPdfTokenizer* fTokenizer;
     PdfContext* fPdfContext;
     SkCanvas* fCanvas;
 
 public:
     PdfTokenLooper(PdfTokenLooper* parent,
-                   SkPdfTokenizer tokenizer,
+                   SkPdfTokenizer* tokenizer,
                    PdfContext* pdfContext,
                    SkCanvas* canvas)
         : fParent(parent), fTokenizer(tokenizer), fPdfContext(pdfContext), fCanvas(canvas) {}
 
     virtual PdfResult consumeToken(PdfToken& token) = 0;
     virtual void loop() = 0;
 
     void setUp(PdfTokenLooper* parent) {
         fParent = parent;
         fTokenizer = parent->fTokenizer;
         fPdfContext = parent->fPdfContext;
         fCanvas = parent->fCanvas;
     }
 };
 
 class PdfMainLooper : public PdfTokenLooper {
 public:
     PdfMainLooper(PdfTokenLooper* parent,
-                  SkPdfTokenizer tokenizer,
+                  SkPdfTokenizer* tokenizer,
                   PdfContext* pdfContext,
                   SkCanvas* canvas)
         : PdfTokenLooper(parent, tokenizer, pdfContext, canvas) {}
 
     virtual PdfResult consumeToken(PdfToken& token);
     virtual void loop();
 };
 
 class PdfInlineImageLooper : public PdfTokenLooper {
 public:
     PdfInlineImageLooper()
-        : PdfTokenLooper(NULL, SkPdfTokenizer(), NULL, NULL) {}
+        : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
 
     virtual PdfResult consumeToken(PdfToken& token);
     virtual void loop();
     PdfResult done();
 };
 
 class PdfCompatibilitySectionLooper : public PdfTokenLooper {
 public:
     PdfCompatibilitySectionLooper()
-        : PdfTokenLooper(NULL, SkPdfTokenizer(), NULL, NULL) {}
+        : PdfTokenLooper(NULL, NULL, NULL, NULL) {}
 
     virtual PdfResult consumeToken(PdfToken& token);
     virtual void loop();
 };
 
 typedef PdfResult (*PdfOperatorRenderer)(PdfContext*, SkCanvas*, PdfTokenLooper**);
 
 map<std::string, PdfOperatorRenderer> gPdfOps;
 
 map<std::string, int> gRenderStats[kCount_PdfResult];
 
 char* gRenderStatsNames[kCount_PdfResult] = {
     "Success",
     "Partially implemented",
     "Not yet implemented",
     "Ignore Error",
     "Error",
     "Unsupported/Unknown"
 };
 
-struct SkPdfStandardFont {
-    const char* fName;
-    bool fIsBold;
-    bool fIsItalic;
-};
-
-static map<std::string, SkPdfStandardFont>& getStandardFonts() {
-    static std::map<std::string, SkPdfStandardFont> gPdfStandardFonts;
-
-    // TODO (edisonn): , vs - ? what does it mean?
-    // TODO (edisonn): MT, PS, Oblique=italic?, ... what does it mean?
-    if (gPdfStandardFonts.empty()) {
-        gPdfStandardFonts["Arial"] = {"Arial", false, false};
-        gPdfStandardFonts["Arial,Bold"] = {"Arial", true, false};
-        gPdfStandardFonts["Arial,BoldItalic"] = {"Arial", true, true};
-        gPdfStandardFonts["Arial,Italic"] = {"Arial", false, true};
-        gPdfStandardFonts["Arial-Bold"] = {"Arial", true, false};
-        gPdfStandardFonts["Arial-BoldItalic"] = {"Arial", true, true};
-        gPdfStandardFonts["Arial-BoldItalicMT"] = {"Arial", true, true};
-        gPdfStandardFonts["Arial-BoldMT"] = {"Arial", true, false};
-        gPdfStandardFonts["Arial-Italic"] = {"Arial", false, true};
-        gPdfStandardFonts["Arial-ItalicMT"] = {"Arial", false, true};
-        gPdfStandardFonts["ArialMT"] = {"Arial", false, false};
-        gPdfStandardFonts["Courier"] = {"Courier New", false, false};
-        gPdfStandardFonts["Courier,Bold"] = {"Courier New", true, false};
-        gPdfStandardFonts["Courier,BoldItalic"] = {"Courier New", true, true};
-        gPdfStandardFonts["Courier,Italic"] = {"Courier New", false, true};
-        gPdfStandardFonts["Courier-Bold"] = {"Courier New", true, false};
-        gPdfStandardFonts["Courier-BoldOblique"] = {"Courier New", true, true};
-        gPdfStandardFonts["Courier-Oblique"] = {"Courier New", false, true};
-        gPdfStandardFonts["CourierNew"] = {"Courier New", false, false};
-        gPdfStandardFonts["CourierNew,Bold"] = {"Courier New", true, false};
-        gPdfStandardFonts["CourierNew,BoldItalic"] = {"Courier New", true, true};
-        gPdfStandardFonts["CourierNew,Italic"] = {"Courier New", false, true};
-        gPdfStandardFonts["CourierNew-Bold"] = {"Courier New", true, false};
-        gPdfStandardFonts["CourierNew-BoldItalic"] = {"Courier New", true, true};
-        gPdfStandardFonts["CourierNew-Italic"] = {"Courier New", false, true};
-        gPdfStandardFonts["CourierNewPS-BoldItalicMT"] = {"Courier New", true, true};
-        gPdfStandardFonts["CourierNewPS-BoldMT"] = {"Courier New", true, false};
-        gPdfStandardFonts["CourierNewPS-ItalicMT"] = {"Courier New", false, true};
-        gPdfStandardFonts["CourierNewPSMT"] = {"Courier New", false, false};
-        gPdfStandardFonts["Helvetica"] = {"Helvetica", false, false};
-        gPdfStandardFonts["Helvetica,Bold"] = {"Helvetica", true, false};
-        gPdfStandardFonts["Helvetica,BoldItalic"] = {"Helvetica", true, true};
-        gPdfStandardFonts["Helvetica,Italic"] = {"Helvetica", false, true};
-        gPdfStandardFonts["Helvetica-Bold"] = {"Helvetica", true, false};
-        gPdfStandardFonts["Helvetica-BoldItalic"] = {"Helvetica", true, true};
-        gPdfStandardFonts["Helvetica-BoldOblique"] = {"Helvetica", true, true};
-        gPdfStandardFonts["Helvetica-Italic"] = {"Helvetica", false, true};
-        gPdfStandardFonts["Helvetica-Oblique"] = {"Helvetica", false, true};
-        gPdfStandardFonts["Times-Bold"] = {"Times", true, false};
-        gPdfStandardFonts["Times-BoldItalic"] = {"Times", true, true};
-        gPdfStandardFonts["Times-Italic"] = {"Times", false, true};
-        gPdfStandardFonts["Times-Roman"] = {"Times New Roman", false, false};
-        gPdfStandardFonts["TimesNewRoman"] = {"Times New Roman", false, false};
-        gPdfStandardFonts["TimesNewRoman,Bold"] = {"Times New Roman", true, false};
-        gPdfStandardFonts["TimesNewRoman,BoldItalic"] = {"Times New Roman", true, true};
-        gPdfStandardFonts["TimesNewRoman,Italic"] = {"Times New Roman", false, true};
-        gPdfStandardFonts["TimesNewRoman-Bold"] = {"Times New Roman", true, false};
-        gPdfStandardFonts["TimesNewRoman-BoldItalic"] = {"Times New Roman", true, true};
-        gPdfStandardFonts["TimesNewRoman-Italic"] = {"Times New Roman", false, true};
-        gPdfStandardFonts["TimesNewRomanPS"] = {"Times New Roman", false, false};
-        gPdfStandardFonts["TimesNewRomanPS-Bold"] = {"Times New Roman", true, false};
-        gPdfStandardFonts["TimesNewRomanPS-BoldItalic"] = {"Times New Roman", true, true};
-        gPdfStandardFonts["TimesNewRomanPS-BoldItalicMT"] = {"Times New Roman", true, true};
-        gPdfStandardFonts["TimesNewRomanPS-BoldMT"] = {"Times New Roman", true, false};
-        gPdfStandardFonts["TimesNewRomanPS-Italic"] = {"Times New Roman", false, true};
-        gPdfStandardFonts["TimesNewRomanPS-ItalicMT"] = {"Times New Roman", false, true};
-        gPdfStandardFonts["TimesNewRomanPSMT"] = {"Times New Roman", false, false};
+static SkTypeface* SkTypefaceFromPdfFont(PdfFont* font) {
+    if (font == NULL) {
+        return SkTypeface::CreateFromName("Times New Roman", SkTypeface::kNormal);
     }
 
-    return gPdfStandardFonts;
-}
-
-static SkTypeface* SkTypefaceFromPdfStandardFont(const char* fontName, bool bold, bool italic) {
-    map<std::string, SkPdfStandardFont>& standardFontMap = getStandardFonts();
-
-    if (standardFontMap.find(fontName) != standardFontMap.end()) {
-        SkPdfStandardFont fontData = standardFontMap[fontName];
-
-        // TODO(edisonn): How does the bold/italic specified in standard definition combines with
-        // the one in /font key? use OR for now.
-        bold = bold || fontData.fIsBold;
-        italic = italic || fontData.fIsItalic;
-
-        SkTypeface* typeface = SkTypeface::CreateFromName(
-            fontData.fName,
-            SkTypeface::Style((bold ? SkTypeface::kBold : 0) |
-                              (italic ? SkTypeface::kItalic : 0)));
-        if (typeface) {
-            typeface->ref();
-        }
-        return typeface;
-    }
-    return NULL;
-}
-
-static SkTypeface* SkTypefaceFromPdfFont(PdfFont* font) {
     PdfObject* fontObject = font->GetObject();
 
     PdfObject* pBaseFont = NULL;
     // TODO(edisonn): warning, PoDoFo has a bug in PdfFont constructor, does not call InitVars()
     // for now fixed locally.
     pBaseFont = fontObject->GetIndirectKey( "BaseFont" );
     const char* pszBaseFontName = pBaseFont->GetName().GetName().c_str();
 
 #ifdef PDF_TRACE
     std::string str;
@@ skipping 32 matching lines @@
     printf("FONT_NOT_FOUND %s\n", pszBaseFontName);
 #endif
 
     // TODO(edisonn): Report Warning, NYI
     return SkTypeface::CreateFromName(
                 "Times New Roman",
                 SkTypeface::Style((font->IsBold() ? SkTypeface::kBold : 0) |
                                   (font->IsItalic() ? SkTypeface::kItalic : 0)));
 }
 
+
 // 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(),
                     (PdfObject*)resolveReferenceObject(&pdfContext->fPdfDoc.podofo(),
                                            fCurFont->GetObject()->GetDictionary().GetKey(PdfName("ToUnicode"))),
                     PdfCMapEncoding::eBaseEncoding_Identity);  // todo, read the base encoding
             gFontsFixed[fCurFont] = enc;
             return enc;
         }
 
         return NULL;
     }
 
     return gFontsFixed[fCurFont];
 }
 
 PdfResult DrawText(PdfContext* pdfContext,
-                   PdfFont* fCurFont,
-                   const PdfString& rString,
+                   const SkPdfObject* str,
                    SkCanvas* canvas)
 {
+
+    SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont;
+    if (skfont == NULL) {
+        skfont = SkPdfFont::Default();
+    }
+
+    SkUnencodedText binary(str);
+
+    SkDecodedText decoded;
+    skfont->encoding()->decodeText(binary, &decoded);
+
+    SkUnicodeText unicode;
+    skfont->ToUnicode(decoded, &unicode);
+
+    SkPaint paint;
+    // TODO(edisonn): when should fCurFont->GetFontSize() used? When cur is fCurFontSize == 0?
+    // Or maybe just not call setTextSize at all?
+    if (pdfContext->fGraphicsState.fCurFontSize != 0) {
+        paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize));
+    }
+
+//    if (fCurFont && fCurFont->GetFontScale() != 0) {
+//        paint.setTextScaleX(SkFloatToScalar(fCurFont->GetFontScale() / 100.0));
+//    }
+
+    pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
+
+    canvas->save();
+
+#if 1
+    SkMatrix matrix = pdfContext->fGraphicsState.fMatrixTm;
+
+    SkPoint point1;
+    pdfContext->fGraphicsState.fMatrixTm.mapXY(SkIntToScalar(0), SkIntToScalar(0), &point1);
+
+    SkMatrix mirror;
+    mirror.setTranslate(0, -point1.y());
+    // TODO(edisonn): fix rotated text, and skewed too
+    mirror.postScale(SK_Scalar1, -SK_Scalar1);
+    // TODO(edisonn): post rotate, skew
+    mirror.postTranslate(0, point1.y());
+
+    matrix.postConcat(mirror);
+
+    canvas->setMatrix(matrix);
+
+    SkTraceMatrix(matrix, "mirrored");
+#endif
+
+    skfont->drawText(unicode, &paint, canvas, &pdfContext->fGraphicsState.fMatrixTm);
+    canvas->restore();
+
+/*
+    PdfString& rString = str->podofo()->GetString();
+
+    //pdfContext->fGraphicsState.fSkFont->GetDecoding()->ToUnicode(rString);
+    //void* text;
+    //int len;
+    //SkPaint paint;
+    //pdfContext->fGraphicsState.fSkFont->drawText(text, len, paint, canvas, &pdfContext->fGraphicsState.fMatrixTm);
+
+    PdfFont* fCurFont = pdfContext->fGraphicsState.fCurFont;
+
     if (!fCurFont)
     {
         // TODO(edisonn): ignore the error, use the default font?
-        return kError_PdfResult;
+        // return kError_PdfResult;
     }
 
-    const PdfEncoding* enc = FixPdfFont(pdfContext, fCurFont);
+    const PdfEncoding* enc = fCurFont ? FixPdfFont(pdfContext, fCurFont) : NULL;
     bool cMapUnicodeFont = enc != NULL;
-    if (!enc) enc = fCurFont->GetEncoding();
+    if (!enc) enc = fCurFont ? fCurFont->GetEncoding() : NULL;
     if (!enc)
     {
         // TODO(edisonn): Can we recover from this error?
-        return kError_PdfResult;
+        //return kError_PdfResult;
     }
 
     PdfString r2 = rString;
     PdfString unicode;
 
     if (cMapUnicodeFont) {
         r2 = PdfString((pdf_utf16be*)rString.GetString(), rString.GetLength() / 2);
     }
 
-    unicode = enc->ConvertToUnicode( r2, fCurFont );
+    unicode = enc ? enc->ConvertToUnicode( r2, fCurFont ) : r2.ToUnicode();
 
 #ifdef PDF_TRACE
     printf("%i %i ? %c rString.len = %i\n", (int)rString.GetString()[0], (int)rString.GetString()[1], (int)rString.GetString()[1], rString.GetLength());
     printf("%i %i %i %i %c unicode.len = %i\n", (int)unicode.GetString()[0], (int)unicode.GetString()[1], (int)unicode.GetString()[2], (int)unicode.GetString()[3], (int)unicode.GetString()[0], unicode.GetLength());
 #endif
 
     SkPaint paint;
     // TODO(edisonn): when should fCurFont->GetFontSize() used? When cur is fCurFontSize == 0?
     // Or maybe just not call setTextSize at all?
     if (pdfContext->fGraphicsState.fCurFontSize != 0) {
         paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize));
     }
-    if (fCurFont->GetFontScale() != 0) {
+    if (fCurFont && fCurFont->GetFontScale() != 0) {
         paint.setTextScaleX(SkFloatToScalar(fCurFont->GetFontScale() / 100.0));
     }
 
     pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
 
     paint.setTypeface(SkTypefaceFromPdfFont(fCurFont));
 
-    paint.setAntiAlias(true);
-    // TODO(edisonn): paint.setStyle(...);
-
     canvas->save();
     SkMatrix matrix = pdfContext->fGraphicsState.fMatrixTm;
 
 #if 0
     // Reverse now the space, otherwise the text is upside down.
     SkScalar z = SkIntToScalar(0);
     SkScalar one = SkIntToScalar(1);
 
     SkPoint normalSpace1[4] = {SkPoint::Make(z, z), SkPoint::Make(one, z), SkPoint::Make(one, one), SkPoint::Make(z, one)};
     SkPoint mirrorSpace1[4];
@@ skipping 71 matching lines @@
 //    unsigned char ch = *(unicode.GetString() + 3);
 //    if ((ch & 0xC0) != 0x80 && ch < 0x80) {
 //        printf("x%i", ch);
 //        SkScalar textWidth = paint.measureText(&ch, 1);
 //        pdfContext->fGraphicsState.fMatrixTm.preTranslate(textWidth, SkDoubleToScalar(0.0));
 //        canvas->drawText(&ch, 1, SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), paint);
 //    }
 
     canvas->restore();
 
-
+*/
     return kPartial_PdfResult;
 }
 
 // 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?
@@ skipping 215 matching lines @@
 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfObject** data) {
     if (ObjectFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return ObjectFromDictionary(pdfDoc, dict, abr, data);
 }
 
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          SkPdfStream** data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+    return PodofoMapper::map(*pdfDoc, *value, data);
+}
+
+bool StreamFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkPdfStream** data) {
+    if (StreamFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return StreamFromDictionary(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);
@@ skipping 351 matching lines @@
     canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
 
     SkRect bbox;
     if (SkRectFromDictionary(&pdfContext->fPdfDoc.podofo(), skobj->podofo()->GetDictionary(), "BBox", &bbox)) {
         canvas->clipRect(bbox, SkRegion::kIntersect_Op, true);  // TODO(edisonn): AA from settings.
     }
 
     // TODO(edisonn): iterate smart on the stream even if it is compressed, tokenize it as we go.
     // For this PdfContentsTokenizer needs to be extended.
 
-    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 {
-        skobj->podofo()->GetStream()->GetFilteredCopy(&uncompressedStream, &uncompressedStreamLength);
-        if (uncompressedStream != NULL && uncompressedStreamLength != 0) {
-            SkPdfTokenizer tokenizer = pdfContext->fPdfDoc.tokenizerOfStream(uncompressedStream, uncompressedStreamLength);
-            PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas);
-            looper.loop();
-        }
-        free(uncompressedStream);
-    } catch (PdfError& e) {
-        ret = kIgnoreError_PdfResult;
-    }
+    SkPdfTokenizer tokenizer(skobj);
+    PdfMainLooper looper(NULL, &tokenizer, pdfContext, canvas);
+    looper.loop();
 
     // 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, const PdfObject& obj) {
     return kNYI_PdfResult;
@@ skipping 434 matching lines @@
 //a number representing a scale factor. There is no initial value for either font or
 //size; they must be specified explicitly using Tf before any text is shown.
 PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     pdfContext->fGraphicsState.fCurFontSize = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
     std::string fontName = pdfContext->fObjectStack.top()->asName()->value();                           pdfContext->fObjectStack.pop();
 
 #ifdef PDF_TRACE
     printf("font name: %s\n", fontName.c_str());
     std::string str;
     pdfContext->fGraphicsState.fResources->podofo()->ToString(str);
-    printf("Print Tf font Resources: %s\n", str.c_str());
+    printf("Print Tf Resources: %s\n", str.c_str());
+    pdfContext->fGraphicsState.fResources->Font()->podofo()->ToString(str);
+    printf("Print Tf Resources/Font: %s\n", str.c_str());
 #endif
 
+    SkPdfFontDictionary* fd = NULL;
+    if (pdfContext->fGraphicsState.fResources->Font()) {
+        SkPdfObject objFont = pdfContext->fGraphicsState.fResources->Font()->get(fontName.c_str());
+        PodofoMapper::map(objFont, &fd);
+
+#ifdef PDF_TRACE
+        objFont.podofo()->ToString(str);
+        printf("Print Font loaded: %s\n", str.c_str());
+        fd->podofo()->ToString(str);
+        printf("Print Font loaded and resolved and upgraded: %s\n", str.c_str());
+#endif
+
+    }
+
+    SkPdfFont* skfont = SkPdfFont::fontFromPdfDictionary(fd);
+
+    if (skfont) {
+        pdfContext->fGraphicsState.fSkFont = skfont;
+    }
+
     // TODO(edisonn): Load font from pdfContext->fGraphicsState.fObjectWithResources ?
     const PdfObject* pFont = resolveReferenceObject(&pdfContext->fPdfDoc.podofo(),
                                                     pdfContext->fGraphicsState.fResources->Font()->get(fontName.c_str()).podofo());
     if( !pFont )
     {
         // TODO(edisonn): try to ignore the error, make sure we do not crash.
         return kIgnoreError_PdfResult;
     }
 
-    pdfContext->fGraphicsState.fCurFont = pdfContext->fPdfDoc.podofo().GetFont( (PdfObject*)pFont );
-    if( !pdfContext->fGraphicsState.fCurFont )
-    {
+    PdfFont* font = pdfContext->fPdfDoc.podofo().GetFont( (PdfObject*)pFont );
+    if (font) {
+        pdfContext->fGraphicsState.fCurFont = font;
+    } else {
         // TODO(edisonn): check ~/crasing, for one of the files PoDoFo throws exception
         // when calling pFont->Reference(), with Linked list corruption.
         return kIgnoreError_PdfResult;
     }
 
     return kPartial_PdfResult;
 }
 
 PdfResult PdfOp_Tj(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         return kIgnoreError_PdfResult;
     }
 
     PdfResult ret = DrawText(pdfContext,
-                             pdfContext->fGraphicsState.fCurFont,
-                             pdfContext->fObjectStack.top()->podofo()->GetString(),
+                             pdfContext->fObjectStack.top(),
                              canvas);
     pdfContext->fObjectStack.pop();
 
     return ret;
 }
 
 PdfResult PdfOp_quote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         return kIgnoreError_PdfResult;
@@ skipping 30 matching lines @@
     if (!pdfContext->fGraphicsState.fTextBlock) {
         // TODO(edisonn): try to recover and draw it any way?
         return kIgnoreError_PdfResult;
     }
 
     SkPdfArray* array = pdfContext->fObjectStack.top()->asArray();
     pdfContext->fObjectStack.pop();
 
     for( int i=0; i<static_cast<int>(array->size()); i++ )
     {
-        if( (*array)[i].asString()) {
+        if( (*array)[i]->asString()) {
+            SkPdfObject* obj = (*array)[i];
             DrawText(pdfContext,
-                           pdfContext->fGraphicsState.fCurFont,
-                           (*array)[i].podofo()->GetString(),
-                           canvas);
-        } else if ((*array)[i].asInteger() || (*array)[i].asNumber()) {
-            double dx = (*array)[i].asNumber()->value();
+                     obj,
+                     canvas);
+        } else if ((*array)[i]->asInteger() || (*array)[i]->asNumber()) {
+            double dx = (*array)[i]->asNumber()->value();
             SkMatrix matrix;
             matrix.setAll(SkDoubleToScalar(1),
                           SkDoubleToScalar(0),
                           // TODO(edisonn): use writing mode, vertical/horizontal.
                           SkDoubleToScalar(-dx),  // amount is substracted!!!
                           SkDoubleToScalar(0),
                           SkDoubleToScalar(1),
                           SkDoubleToScalar(0),
                           SkDoubleToScalar(0),
                           SkDoubleToScalar(0),
@@ skipping 538 matching lines @@
         for (iter = gRenderStats[i].begin(); iter != gRenderStats[i].end(); ++iter) {
             printf("%s: %s -> count %i\n", gRenderStatsNames[i], iter->first.c_str(), iter->second);
         }
     }
 }
 
 PdfResult PdfMainLooper::consumeToken(PdfToken& token) {
     if (token.fType == kKeyword_TokenType)
     {
         // TODO(edisonn): log trace flag (verbose, error, info, warning, ...)
-#ifdef PDF_TRACE
-        printf("KEYWORD: %s\n", token.fKeyword);
-#endif
         PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[token.fKeyword];
         if (pdfOperatorRenderer) {
             // caller, main work is done by pdfOperatorRenderer(...)
             PdfTokenLooper* childLooper = NULL;
             gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][token.fKeyword]++;
 
             if (childLooper) {
                 childLooper->setUp(this);
                 childLooper->loop();
                 delete childLooper;
             }
         } else {
             gRenderStats[kUnsupported_PdfResult][token.fKeyword]++;
         }
     }
     else if (token.fType == kObject_TokenType)
     {
-#ifdef PDF_TRACE
-        std::string _var;
-        token.fObject->podofo()->ToString(_var);
-        printf("var: %s\n", _var.c_str());
-#endif
         fPdfContext->fObjectStack.push( token.fObject );
     }
     else if ( token.fType == kImageData_TokenType) {
         // TODO(edisonn): implement inline image.
     }
     else {
         return kIgnoreError_PdfResult;
     }
     return kOK_PdfResult;
 }
@@ skipping 115 matching lines @@
 
                 SkBitmap bitmap;
 #ifdef PDF_DEBUG_3X
                 setup_bitmap(&bitmap, 3 * (int)SkScalarToDouble(rect.width()), 3 * (int)SkScalarToDouble(rect.height()))
 #else
                 setup_bitmap(&bitmap, (int)SkScalarToDouble(rect.width()), (int)SkScalarToDouble(rect.height()));
 #endif
                 SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
                 SkCanvas canvas(device);
 
-                SkPdfTokenizer tokenizer = doc.tokenizerOfPage(pn);
+                SkPdfTokenizer* tokenizer = doc.tokenizerOfPage(pn);
 
                 PdfContext pdfContext(doc);
                 pdfContext.fOriginalMatrix = SkMatrix::I();
                 pdfContext.fGraphicsState.fResources = NULL;
                 PodofoMapper::map(*page->Resources(), &pdfContext.fGraphicsState.fResources);
 
                 gPdfContext = &pdfContext;
                 gDumpBitmap = &bitmap;
                 gDumpCanvas = &canvas;
 
@@ skipping 36 matching lines @@
 
                 canvas.setMatrix(pdfContext.fOriginalMatrix);
 
 #ifndef PDF_DEBUG_NO_PAGE_CLIPING
                 canvas.clipRect(SkRect::MakeXYWH(z, z, w, h), SkRegion::kIntersect_Op, true);
 #endif
 
                 PdfMainLooper looper(NULL, tokenizer, &pdfContext, &canvas);
                 looper.loop();
 
+                delete tokenizer;
+
                 canvas.flush();
 
                 SkString out;
                 out.appendf("%s-%i.png", inputFileName.c_str(), pn);
                 SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
             }
             return true;
         }
     }
     catch( PdfError & e )
@@ skipping 213 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif