pdfviewer: make pdfviewer compile on mac

experimental/PdfViewer/SkPdfRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkDevice.h"
 #include "SkForceLinking.h"
@@ skipping 461 matching lines @@
 // skia format, through a table
 
 // this functions returns the image, it does not look at the smask.
 
 static SkBitmap* getImageFromObjectCore(SkPdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) {
     if (image == NULL || !image->hasStream()) {
         // TODO(edisonn): report warning to be used in testing.
         return NULL;
     }
 
-    int64_t bpc = image->BitsPerComponent(pdfContext->fPdfDoc);
-    int64_t width = image->Width(pdfContext->fPdfDoc);
-    int64_t height = image->Height(pdfContext->fPdfDoc);
+    int bpc = (int)image->BitsPerComponent(pdfContext->fPdfDoc);
+    int width = (int)image->Width(pdfContext->fPdfDoc);
+    int height = (int)image->Height(pdfContext->fPdfDoc);
     std::string colorSpace = "DeviceRGB";
 
     bool indexed = false;
     SkPMColor colors[256];
     int cnt = 0;
 
     // TODO(edisonn): color space can be an array too!
     if (image->isColorSpaceAName(pdfContext->fPdfDoc)) {
         colorSpace = image->getColorSpaceAsName(pdfContext->fPdfDoc);
     } else if (image->isColorSpaceAArray(pdfContext->fPdfDoc)) {
         SkPdfArray* array = image->getColorSpaceAsArray(pdfContext->fPdfDoc);
         if (array && array->size() == 4 && array->objAtAIndex(0)->isName("Indexed") &&
                                            (array->objAtAIndex(1)->isName("DeviceRGB") || array->objAtAIndex(1)->isName("RGB")) &&
                                            array->objAtAIndex(2)->isInteger() &&
                                            array->objAtAIndex(3)->isHexString()
                                            ) {
             // TODO(edisonn): suport only DeviceRGB for now.
             indexed = true;
-            cnt = array->objAtAIndex(2)->intValue() + 1;
+            cnt = (int)array->objAtAIndex(2)->intValue() + 1;
             if (cnt > 256) {
                 // TODO(edionn): report NYIs
                 return NULL;
             }
             SkColorTable colorTable(cnt);
             NotOwnedString data = array->objAtAIndex(3)->strRef();
             if (data.fBytes != (unsigned int)cnt * 3) {
                 // TODO(edionn): report error/warning
                 return NULL;
             }
@@ skipping 520 matching lines @@
     pdfContext->fGraphicsState.fTextLeading = ty;
 
     return kOK_SkPdfResult;
 }
 
 static SkPdfResult PdfOp_Td(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
 #ifdef PDF_TRACE
     printf("stack size = %i\n", (int)pdfContext->fObjectStack.size());
 #endif
     double ty = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
-    SkPdfNativeObject* obj = pdfContext->fObjectStack.top();
-    obj = obj;
     double tx = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop();
 
     double array[6] = {1, 0, 0, 1, tx, -ty};
     SkMatrix matrix = SkMatrixFromPdfMatrix(array);
 
     pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
     pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix);
 
     return kPartial_SkPdfResult;
 }
@@ skipping 382 matching lines @@
 }
 
 static SkPdfResult PdfOp_ET(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     if (!pdfContext->fGraphicsState.fTextBlock) {
         return kIgnoreError_SkPdfResult;
     }
     // TODO(edisonn): anything else to be done once we are done with draw text? Like restore stack?
     return kOK_SkPdfResult;
 }
 
-SkPdfResult skpdfGraphicsStateApplyFontCore(SkPdfContext* pdfContext, const SkPdfNativeObject* fontName, double fontSize) {
+static SkPdfResult skpdfGraphicsStateApplyFontCore(SkPdfContext* pdfContext, const SkPdfNativeObject* fontName, double fontSize) {
 #ifdef PDF_TRACE
     printf("font name: %s\n", fontName->nameValue2().c_str());
 #endif
 
     if (!pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)) {
         // TODO(edisonn): try to recover and draw it any way?
         return kIgnoreError_SkPdfResult;
     }
 
     SkPdfNativeObject* objFont = pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)->get(fontName);
@@ skipping 333 matching lines @@
 static SkPdfResult PdfOp_EI(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
 #ifdef ASSERT_BAD_PDF_OPS
     SkASSERT(false);  // must be processed in inline image looper, but let's
                       // have the assert when testing good pdfs.
 #endif
     return kIgnoreError_SkPdfResult;
 }
 
 
 // TODO(edisonn): security review here, make sure all parameters are valid, and safe.
-SkPdfResult skpdfGraphicsStateApply_ca(SkPdfContext* pdfContext, double ca) {
+static SkPdfResult skpdfGraphicsStateApply_ca(SkPdfContext* pdfContext, double ca) {
     pdfContext->fGraphicsState.fNonStroking.fOpacity = ca;
     return kOK_SkPdfResult;
 }
 
-SkPdfResult skpdfGraphicsStateApply_CA(SkPdfContext* pdfContext, double CA) {
+static SkPdfResult skpdfGraphicsStateApply_CA(SkPdfContext* pdfContext, double CA) {
     pdfContext->fGraphicsState.fStroking.fOpacity = CA;
     return kOK_SkPdfResult;
 }
 
-SkPdfResult skpdfGraphicsStateApplyLW(SkPdfContext* pdfContext, double lineWidth) {
+static SkPdfResult skpdfGraphicsStateApplyLW(SkPdfContext* pdfContext, double lineWidth) {
     pdfContext->fGraphicsState.fLineWidth = lineWidth;
     return kOK_SkPdfResult;
 }
 
-SkPdfResult skpdfGraphicsStateApplyLC(SkPdfContext* pdfContext, int64_t lineCap) {
+static SkPdfResult skpdfGraphicsStateApplyLC(SkPdfContext* pdfContext, int64_t lineCap) {
     pdfContext->fGraphicsState.fLineCap = (int)lineCap;
     return kOK_SkPdfResult;
 }
 
-SkPdfResult skpdfGraphicsStateApplyLJ(SkPdfContext* pdfContext, int64_t lineJoin) {
+static SkPdfResult skpdfGraphicsStateApplyLJ(SkPdfContext* pdfContext, int64_t lineJoin) {
     pdfContext->fGraphicsState.fLineJoin = (int)lineJoin;
     return kOK_SkPdfResult;
 }
 
-SkPdfResult skpdfGraphicsStateApplyML(SkPdfContext* pdfContext, double miterLimit) {
+static SkPdfResult skpdfGraphicsStateApplyML(SkPdfContext* pdfContext, double miterLimit) {
     pdfContext->fGraphicsState.fMiterLimit = miterLimit;
     return kOK_SkPdfResult;
 }
 
 // TODO(edisonn): implement all rules, as of now 3) and 5) and 6) do not seem suported by skia, but I am not sure
 /*
 1) [ ] 0 No dash; solid, unbroken lines
 2) [3] 0 3 units on, 3 units off, …
 3) [2] 1 1 on, 2 off, 2 on, 2 off, …
 4) [2 1] 0 2 on, 1 off, 2 on, 1 off, …
 5) [3 5] 6 2 off, 3 on, 5 off, 3 on, 5 off, …
 6) [2 3] 11 1 on, 3 off, 2 on, 3 off, 2 on, …
  */
 
-SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* intervals, SkPdfNativeObject* phase) {
+static SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* intervals, SkPdfNativeObject* phase) {
     int cnt = intervals->size();
     if (cnt >= 256) {
         // TODO(edisonn): report error/warning, unsuported;
         // TODO(edisonn): alloc memory
         return kIgnoreError_SkPdfResult;
     }
     for (int i = 0; i < cnt; i++) {
         if (!intervals->objAtAIndex(i)->isNumber()) {
             // TODO(edisonn): report error/warning
             return kIgnoreError_SkPdfResult;
@@ skipping 17 matching lines @@
     pdfContext->fGraphicsState.fDashArrayLength = cnt;
     pdfContext->fGraphicsState.fDashPhase = phase->scalarValue();
     if (pdfContext->fGraphicsState.fDashPhase == 0) {
         // other rules, changes?
         pdfContext->fGraphicsState.fDashPhase = total;
     }
 
     return kOK_SkPdfResult;
 }
 
-SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* dash) {
+static SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* dash) {
     // TODO(edisonn): verify input
     if (!dash || dash->isArray() || dash->size() != 2 || !dash->objAtAIndex(0)->isArray() || !dash->objAtAIndex(1)->isNumber()) {
         // TODO(edisonn): report error/warning
         return kIgnoreError_SkPdfResult;
     }
     return skpdfGraphicsStateApplyD(pdfContext, (SkPdfArray*)dash->objAtAIndex(0), dash->objAtAIndex(1));
 }
 
-void skpdfGraphicsStateApplyFont(SkPdfContext* pdfContext, SkPdfArray* fontAndSize) {
+static void skpdfGraphicsStateApplyFont(SkPdfContext* pdfContext, SkPdfArray* fontAndSize) {
     if (!fontAndSize || fontAndSize->isArray() || fontAndSize->size() != 2 || !fontAndSize->objAtAIndex(0)->isName() || !fontAndSize->objAtAIndex(1)->isNumber()) {
         // TODO(edisonn): report error/warning
         return;
     }
     skpdfGraphicsStateApplyFontCore(pdfContext, fontAndSize->objAtAIndex(0), fontAndSize->objAtAIndex(1)->numberValue());
 }
 
 
 //lineWidth w Set the line width in the graphics state (see “Line Width” on page 152).
 static SkPdfResult PdfOp_w(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
@@ skipping 71 matching lines @@
         // TABLE 7.3 Standard nonseparable blend modes
         gPdfBlendModes.set("Hue", SkXfermode::kHue_Mode);
         gPdfBlendModes.set("Saturation", SkXfermode::kSaturation_Mode);
         gPdfBlendModes.set("Color", SkXfermode::kColor_Mode);
         gPdfBlendModes.set("Luminosity", SkXfermode::kLuminosity_Mode);
     }
 };
 
 InitBlendModes _gDummyInniter;
 
-SkXfermode::Mode xferModeFromBlendMode(const char* blendMode, size_t len) {
+static SkXfermode::Mode xferModeFromBlendMode(const char* blendMode, size_t len) {
     SkXfermode::Mode mode = (SkXfermode::Mode)(SkXfermode::kLastMode + 1);
     if (gPdfBlendModes.find(blendMode, len, &mode)) {
         return mode;
     }
 
     return (SkXfermode::Mode)(SkXfermode::kLastMode + 1);
 }
 
-void skpdfGraphicsStateApplyBM_name(SkPdfContext* pdfContext, const std::string& blendMode) {
+static void skpdfGraphicsStateApplyBM_name(SkPdfContext* pdfContext, const std::string& blendMode) {
     SkXfermode::Mode mode = xferModeFromBlendMode(blendMode.c_str(), blendMode.length());
     if (mode <= SkXfermode::kLastMode) {
         pdfContext->fGraphicsState.fBlendModesLength = 1;
         pdfContext->fGraphicsState.fBlendModes[0] = mode;
     } else {
         // TODO(edisonn): report unknown blend mode
     }
 }
 
-void skpdfGraphicsStateApplyBM_array(SkPdfContext* pdfContext, SkPdfArray* blendModes) {
+static void skpdfGraphicsStateApplyBM_array(SkPdfContext* pdfContext, SkPdfArray* blendModes) {
     if (!blendModes || blendModes->isArray() || blendModes->size() == 0 || blendModes->size() > 256) {
         // TODO(edisonn): report error/warning
         return;
     }
     SkXfermode::Mode modes[256];
     int cnt = blendModes->size();
     for (int i = 0; i < cnt; i++) {
         SkPdfNativeObject* name = blendModes->objAtAIndex(i);
         if (!name->isName()) {
             // TODO(edisonn): report error/warning
             return;
         }
         SkXfermode::Mode mode = xferModeFromBlendMode(name->c_str(), name->lenstr());
         if (mode > SkXfermode::kLastMode) {
             // TODO(edisonn): report error/warning
             return;
         }
     }
 
     pdfContext->fGraphicsState.fBlendModesLength = cnt;
     for (int i = 0; i < cnt; i++) {
         pdfContext->fGraphicsState.fBlendModes[i] = modes[i];
     }
 }
 
-void skpdfGraphicsStateApplySMask_dict(SkPdfContext* pdfContext, SkPdfDictionary* sMask) {
+static void skpdfGraphicsStateApplySMask_dict(SkPdfContext* pdfContext, SkPdfDictionary* sMask) {
     // TODO(edisonn): verify input
     if (pdfContext->fPdfDoc->mapper()->mapSoftMaskDictionary(sMask)) {
         pdfContext->fGraphicsState.fSoftMaskDictionary = (SkPdfSoftMaskDictionary*)sMask;
     } else if (pdfContext->fPdfDoc->mapper()->mapSoftMaskImageDictionary(sMask)) {
         SkPdfSoftMaskImageDictionary* smid = (SkPdfSoftMaskImageDictionary*)sMask;
         pdfContext->fGraphicsState.fSMask = getImageFromObject(pdfContext, smid, true);
     } else {
         // TODO (edisonn): report error/warning
     }
 }
 
-void skpdfGraphicsStateApplySMask_name(SkPdfContext* pdfContext, const std::string& sMask) {
+static void skpdfGraphicsStateApplySMask_name(SkPdfContext* pdfContext, const std::string& sMask) {
     if (sMask == "None") {
         pdfContext->fGraphicsState.fSoftMaskDictionary = NULL;
         pdfContext->fGraphicsState.fSMask = NULL;
         return;
     }
 
     //Next, get the ExtGState Dictionary from the Resource Dictionary:
     SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfDoc);
 
     if (extGStateDictionary == NULL) {
 #ifdef PDF_TRACE
         printf("ExtGState is NULL!\n");
 #endif
         // TODO (edisonn): report error/warning
         return;
     }
 
     SkPdfNativeObject* obj = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(sMask.c_str()));
     if (!obj || !obj->isDictionary()) {
         // TODO (edisonn): report error/warning
         return;
     }
 
     pdfContext->fGraphicsState.fSoftMaskDictionary = NULL;
     pdfContext->fGraphicsState.fSMask = NULL;
 
     skpdfGraphicsStateApplySMask_dict(pdfContext, obj->asDictionary());
 }
 
-void skpdfGraphicsStateApplyAIS(SkPdfContext* pdfContext, bool alphaSource) {
+static void skpdfGraphicsStateApplyAIS(SkPdfContext* pdfContext, bool alphaSource) {
     pdfContext->fGraphicsState.fAlphaSource = alphaSource;
 }
 
 
 //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).
 static SkPdfResult PdfOp_gs(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     SkPdfNativeObject* name = pdfContext->fObjectStack.top();    pdfContext->fObjectStack.pop();
 
 #ifdef PDF_TRACE
@@ skipping 570 matching lines @@
 
     rect = SkRect::MakeWH(width, height);
 
     setup_bitmap(output, (int)SkScalarToDouble(width), (int)SkScalarToDouble(height));
 
     SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (*output)));
     SkCanvas canvas(device);
 
     return renderer.renderPage(page, &canvas, rect);
 }