isolate podofo to prepare for native parser, autogenerate PDF API during build

experimental/PdfViewer/pdfparser/podofo/SkPodofoUtils.cpp

+
+#include "SkPodofoUtils.h"
+#include "SkMatrix.h"
+#include "SkPdfHeaders_autogen.h"
+#include "SkPdfMapper_autogen.h"
+
+#include "podofo.h"
+
+const PoDoFo::PdfObject* resolveReferenceObject(const SkPodofoParsedPDF* pdfDoc,
+                                  const PoDoFo::PdfObject* obj,
+                                  bool resolveOneElementArrays) {
+    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.
+            PoDoFo::PdfReference& ref = (PoDoFo::PdfReference&)obj->GetReference();
+            obj = pdfDoc->podofo()->GetObjects().GetObject(ref);
+        } else {
+            obj = &obj->GetArray()[0];
+        }
+    }
+
+    return obj;
+}
+
+// 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(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::PdfDictionary& dict,
+                        const char* key,
+                        long* data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)));
+
+    if (value == NULL || !value->IsNumber()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetNumber();
+    return true;
+}
+
+bool LongFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::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 SkPodofoParsedPDF* pdfDoc,
+                          const PoDoFo::PdfDictionary& dict,
+                          const char* key,
+                          double* data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)));
+
+    if (value == NULL || (!value->IsReal() && !value->IsNumber())) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetReal();
+    return true;
+}
+
+bool DoubleFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                          const PoDoFo::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 SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::PdfDictionary& dict,
+                        const char* key,
+                        bool* data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)));
+
+    if (value == NULL || !value->IsBool()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetBool();
+    return true;
+}
+
+bool BoolFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::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 SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::PdfDictionary& dict,
+                        const char* key,
+                        std::string* data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)),
+                                              true);
+    if (value == NULL || !value->IsName()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetName().GetName();
+    return true;
+}
+
+bool NameFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::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 SkPodofoParsedPDF* pdfDoc,
+                          const PoDoFo::PdfDictionary& dict,
+                          const char* key,
+                          std::string* data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)),
+                                              true);
+    if (value == NULL || (!value->IsString() && !value->IsHexString())) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    *data = value->GetString().GetString();
+    return true;
+}
+
+bool StringFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                          const PoDoFo::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 SkMatrixFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                            const PoDoFo::PdfDictionary& dict,
+                            const char* key,
+                            SkMatrix** matrix) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                                    dict.GetKey(PoDoFo::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++) {
+        const PoDoFo::PdfObject* elem = resolveReferenceObject(pdfDoc, &value->GetArray()[i]);
+        if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
+            return false;
+        }
+        array[i] = elem->GetReal();
+    }
+
+    *matrix = new SkMatrix();
+    **matrix = SkMatrixFromPdfMatrix(array);
+    return true;
+}
+
+bool SkMatrixFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkMatrix** data) {
+    if (SkMatrixFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return SkMatrixFromDictionary(pdfDoc, dict, abr, data);
+
+}
+
+bool SkRectFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                          const PoDoFo::PdfDictionary& dict,
+                          const char* key,
+                          SkRect** rect) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                                    dict.GetKey(PoDoFo::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++) {
+        const PoDoFo::PdfObject* elem = resolveReferenceObject(pdfDoc, &value->GetArray()[i]);
+        if (elem == NULL || (!elem->IsReal() && !elem->IsNumber())) {
+            return false;
+        }
+        array[i] = elem->GetReal();
+    }
+
+    *rect = new SkRect();
+    **rect = SkRect::MakeLTRB(SkDoubleToScalar(array[0]),
+                              SkDoubleToScalar(array[1]),
+                              SkDoubleToScalar(array[2]),
+                              SkDoubleToScalar(array[3]));
+    return true;
+}
+
+bool SkRectFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkRect** data) {
+    if (SkRectFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return SkRectFromDictionary(pdfDoc, dict, abr, data);
+
+}
+
+
+SkPdfObject* get(const SkPdfObject* obj, const char* key, const char* abr = "") {
+    PoDoFo::PdfObject* podofoObj = NULL;
+    if (obj == NULL) return NULL;
+    const SkPdfDictionary* dict = obj->asDictionary();
+    if (dict == NULL) return NULL;
+    if (!dict->podofo()->IsDictionary()) return NULL;
+    ObjectFromDictionary(dict->doc(), dict->podofo()->GetDictionary(), key, abr, &podofoObj);
+    SkPdfObject* ret = NULL;
+    obj->doc()->mapper()->mapObject(podofoObj, &ret);
+    return ret;
+}
+
+bool ArrayFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                         const PoDoFo::PdfDictionary& dict,
+                         const char* key,
+                         const char* abr,
+                         SkPdfArray* data) {return false;}
+
+bool FileSpecFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                         const PoDoFo::PdfDictionary& dict,
+                         const char* key,
+                         const char* abr,
+                         SkPdfFileSpec* data) {return false;}
+
+bool StreamFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                         const PoDoFo::PdfDictionary& dict,
+                         const char* key,
+                         const char* abr,
+                         SkPdfStream** data);
+
+bool TreeFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                         const PoDoFo::PdfDictionary& dict,
+                         const char* key,
+                         const char* abr,
+                         SkPdfTree** data) {return false;}
+
+bool DateFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                         const PoDoFo::PdfDictionary& dict,
+                         const char* key,
+                         const char* abr,
+                         SkPdfDate* data) {return false;}
+
+bool FunctionFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                         const PoDoFo::PdfDictionary& dict,
+                         const char* key,
+                         const char* abr,
+                         SkPdfFunction* data) {return false;}
+
+
+
+
+bool ArrayFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                              const PoDoFo::PdfDictionary& dict,
+                              const char* key,
+                              SkPdfArray** data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)),
+                                              true);
+    if (value == NULL || !value->IsArray()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    return pdfDoc->mapper()->mapArray(value, data);
+}
+
+
+bool ArrayFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkPdfArray** data) {
+    if (ArrayFromDictionary(pdfDoc, dict, key, data)) return true;
+    if (abr == NULL || *abr == '\0') return false;
+    return ArrayFromDictionary(pdfDoc, dict, abr, data);
+}
+
+/*
+bool DictionaryFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                              const PoDoFo::PdfDictionary& dict,
+                              const char* key,
+                              SkPoDoFo::PdfDictionary** data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)),
+                                              true);
+    if (value == NULL || !value->IsDictionary()) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+
+    return pdfDoc->mapper()->mapDictionary(value, data);
+}
+
+bool DictionaryFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        SkPoDoFo::PdfDictionary** 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 SkPodofoParsedPDF* pdfDoc,
+                          const PoDoFo::PdfDictionary& dict,
+                          const char* key,
+                          PoDoFo::PdfObject** data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)),
+                                              true);
+    if (value == NULL) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+    *data = (PoDoFo::PdfObject*)value;
+    return true;
+}
+
+bool ObjectFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::PdfDictionary& dict,
+                        const char* key,
+                        const char* abr,
+                        PoDoFo::PdfObject** 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 SkPodofoParsedPDF* pdfDoc,
+                          const PoDoFo::PdfDictionary& dict,
+                          const char* key,
+                          SkPdfStream** data) {
+    const PoDoFo::PdfObject* value = resolveReferenceObject(pdfDoc,
+                                              dict.GetKey(PoDoFo::PdfName(key)),
+                                              true);
+    if (value == NULL) {
+        return false;
+    }
+    if (data == NULL) {
+        return true;
+    }
+    return pdfDoc->mapper()->mapStream(value, data);
+}
+
+bool StreamFromDictionary(const SkPodofoParsedPDF* pdfDoc,
+                        const PoDoFo::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);
+}
+
+