Object model generated from pdf spec 1.4, draft code

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"
@@ skipping 12 matching lines @@
 
 #include "podofo.h"
 using namespace PoDoFo;
 
 bool LongFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         long* data);
 
+bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          const char* abr,
+                          double* 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);
 
+bool StringFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          const char* abr,
+                          std::string* data);
+
+class SkPdfDictionary;
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
+                              const PdfDictionary& dict,
+                              const char* key,
+                              const char* abr,
+                              SkPdfDictionary** data);
+
+class SkPdfObject;
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkPdfObject** 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
@@ skipping 714 matching lines @@
 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 DoubleFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          double* data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)));
+
+    if (value == NULL || !value->IsReal()) {
+        return false;
+    }
+
+    *data = value->GetReal();
+    return true;
+}
+
+bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          const char* abr,
+                          double* data) {
+    if (DoubleFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return DoubleFromDictionary(pdfDoc, dict, abr, data);
+}
+
+
 bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         bool* data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsBool()) {
         return false;
     }
@@ skipping 30 matching lines @@
 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);
 }
 
+bool StringFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          std::string* data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL || (!value->IsString() && !value->IsHexString())) {
+        return false;
+    }
+
+    *data = value->GetString().GetString();
+    return true;
+}
+
+bool StringFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          const char* abr,
+                          std::string* data) {
+    if (StringFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return StringFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
+                              const PdfDictionary& dict,
+                              const char* key,
+                              SkPdfDictionary** data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL || !value->IsDictionary()) {
+        return false;
+    }
+
+    return PodofoMapper::mapDictionary(*pdfDoc, *value, (SkPdfObject**)data);
+}
+
+bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
+                        const PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkPdfDictionary** data) {
+    if (DictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return DictionaryFromDictionary(pdfDoc, dict, abr, data);
+}
+
+bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
+                          const PdfDictionary& dict,
+                          const char* key,
+                          SkPdfObject** data) {
+    const PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PdfName(key)),
+                                              true);
+    if (value == NULL) {
+        return false;
+    }
+    return PodofoMapper::mapObject(*pdfDoc, *value, data);
+}
+
+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);
+}
+
+
 // 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, const SkPdfImage* image, bool transparencyMask) {
+SkBitmap getImageFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* 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();
+    long bpc = image->BitsPerComponent();
+    long width = image->Width();
+    long height = image->Height();
+    SkPdfObject* colorSpaceDict = image->ColorSpace();
+    std::string colorSpace = "DeviceRGB";
+    // TODO(edisonn): for multiple type fileds, generate code, like, isName(), isArray(), ...and fields like colorSpace_name(), colorSpace_array()
+    // so we do nto go to podofo anywhere in our cpp file
+    if (colorSpaceDict && colorSpaceDict->podofo() && colorSpaceDict->podofo()->IsName()) {
+        colorSpace = colorSpaceDict->podofo()->GetName().GetName();
+    }
 
 /*
     bool imageMask = image->imageMask();
 
     if (imageMask) {
         if (bpc != 0 && bpc != 1) {
             // TODO(edisonn): report warning to be used in testing.
             return SkBitmap();
         }
         bpc = 1;
@@ skipping 25 matching lines @@
             (unsigned char*)uncompressedStream, uncompressedStreamLength,
             width, height, bytesPerLine,
             bpc, colorSpace,
             transparencyMask);
 
     free(uncompressedStream);
 
     return bitmap;
 }
 
-SkBitmap getSmaskFromObject(PdfContext* pdfContext, const SkPdfImage* obj) {
+SkBitmap getSmaskFromObject(PdfContext* pdfContext, const SkPdfImageDictionary* 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);
+        SkPdfImageDictionary skxobjmask(pdfContext->fPdfDoc, sMask);
         return getImageFromObject(pdfContext, &skxobjmask, true);
     }
 
     // TODO(edisonn): implement GS SMask. Default to empty right now.
     return pdfContext->fGraphicsState.fSMask;
 }
 
-PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfImage* skpdfimage) {
+PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfImageDictionary* 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));
@@ skipping 157 matching lines @@
 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 (!PodofoMapper::mapXObjectDictionary(*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 kObjectDictionaryXObjectDictionaryImageDictionary_SkPdfObjectType:
+            ret = doXObject_Image(pdfContext, canvas, skobj->asImageDictionary());
             break;
-        case kObjectDictionaryXObjectForm_SkPdfObjectType:
-            ret = doXObject_Form(pdfContext, canvas, obj);
+        case kObjectDictionaryXObjectDictionaryType1FormDictionary_SkPdfObjectType:
+            ret = doXObject_Form(pdfContext, canvas, obj);//skobj->asType1FormDictionary());
             break;
         //case kObjectDictionaryXObjectPS_SkPdfObjectType:
             //return doXObject_PS(skxobj.asPS());
     }
 
     delete skobj;
     return ret;
 }
 
 PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
@@ skipping 721 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();
 
+#ifdef PDF_TRACE
+    std::string str;
+#endif
+
     const PdfDictionary& pageDict = pdfContext->fGraphicsState.fObjectWithResources->GetDictionary();
+
+#ifdef PDF_TRACE
+    pdfContext->fGraphicsState.fObjectWithResources->ToString(str);
+    printf("Print Object with resources: %s\n", str.c_str());
+#endif
+
     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;
     }
@@ skipping 779 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif