experimental/PdfViewer/src/SkPdfRenderer.cpp

   1 /*
   2  * Copyright 2013 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkPdfRenderer.h"
   9
  10 #include "SkBitmapDevice.h"
  11 #include "SkCanvas.h"
  12 #include "SkColorPriv.h"
  13 #include "SkDevice.h"
  14 #include "SkForceLinking.h"
  15 #include "SkGraphics.h"
  16 #include "SkImageDecoder.h"
  17 #include "SkImageEncoder.h"
  18 #include "SkOSFile.h"
  19 #include "SkPicture.h"
  20 #include "SkPdfFont.h"
  21 #include "SkPdfGraphicsState.h"
  22 #include "SkPdfHeaders_autogen.h"
  23 #include "SkPdfMapper_autogen.h"
  24 #include "SkPdfNativeTokenizer.h"
  25 #include "SkPdfRenderer.h"
  26 #include "SkPdfReporter.h"
  27 #include "SkPdfTokenLooper.h"
  28 #include "SkPdfUtils.h"
  29 #include "SkStream.h"
  30 #include "SkTypeface.h"
  31 #include "SkTArray.h"
  32 #include "SkTDict.h"
  33
  34 // TODO(edisonn): #ifdef these ones, as they are used only for debugging.
  35 extern "C" SkPdfContext* gPdfContext;
  36
  37 __SK_FORCE_IMAGE_DECODER_LINKING;
  38
  39 // TODO(edisonn): tool, show what objects were read during rendering - will help to identify
  40 //                features with incomplete implementation
  41 // TODO(edisonn): security - validate all the user input, all pdf!
  42 // TODO(edisonn): testability -add option to render without text, or only render text
  43
  44 // Helper macros to load variables from stack, and automatically check their type.
  45 #define EXPECT_OPERANDS(name,pdfContext,n) \
  46     bool __failed = pdfContext->fObjectStack.count() < n; \
  47     SkPdfREPORTCODE(const char* __operator_name = name); \
  48     SkPdfREPORTCODE((void)__operator_name); \
  49     SkPdfReportIf(pdfContext->fObjectStack.count() < n, \
  50                   kIgnoreError_SkPdfIssueSeverity, \
  51                   kStackOverflow_SkPdfIssue, \
  52                   "Not enought parameters.", NULL, pdfContext); \
  53     SkDEBUGCODE(int __cnt = n);
  54
  55 #define POP_OBJ(pdfContext,name) \
  56     SkDEBUGCODE(__cnt--); \
  57     SkASSERT(__cnt >= 0); \
  58     SkPdfNativeObject* name = NULL; \
  59     __failed = __failed || pdfContext->fObjectStack.count() == 0; \
  60     if (pdfContext->fObjectStack.count() > 0) { \
  61         name = pdfContext->fObjectStack.top(); \
  62         pdfContext->fObjectStack.pop(); \
  63     }
  64
  65 // TODO(edisonn): make all pop function to use name##_obj
  66 #define POP_NUMBER(pdfContext,name) \
  67     SkDEBUGCODE(__cnt--); \
  68     SkASSERT(__cnt >= 0); \
  69     double name = 0; \
  70     SkPdfNativeObject* name##_obj = NULL; \
  71     __failed = __failed || pdfContext->fObjectStack.count() == 0; \
  72     if (pdfContext->fObjectStack.count() > 0) { \
  73         name##_obj = pdfContext->fObjectStack.top(); \
  74         pdfContext->fObjectStack.pop(); \
  75         if (!name##_obj || !name##_obj->isNumber()) { \
  76             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, \
  77                                       __operator_name, \
  78                                       name##_obj, \
  79                                       SkPdfNativeObject::_kNumber_PdfObjectType, \
  80                                       NULL);\
  81             __failed = true;\
  82         } else { \
  83             name = name##_obj->numberValue(); \
  84         } \
  85     }
  86
  87 #define POP_INTEGER(pdfContext,name) \
  88     SkDEBUGCODE(__cnt--); \
  89     SkASSERT(__cnt >= 0); \
  90     int64_t name = 0; \
  91     __failed = __failed || pdfContext->fObjectStack.count() == 0; \
  92     SkPdfNativeObject* name##_obj = NULL; \
  93     if (pdfContext->fObjectStack.count() > 0) { \
  94         name##_obj = pdfContext->fObjectStack.top(); \
  95         pdfContext->fObjectStack.pop(); \
  96         if (!name##_obj || !name##_obj->isInteger()) { \
  97             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, \
  98                                       __operator_name, \
  99                                       name##_obj, \
 100                                       SkPdfNativeObject::kInteger_PdfObjectType, \
 101                                       NULL);\
 102             __failed = true;\
 103         } else { \
 104             name = name##_obj->intValue(); \
 105         } \
 106     }
 107
 108 #define POP_NUMBER_INTO(pdfContext,var) \
 109     SkDEBUGCODE(__cnt--); \
 110     SkASSERT(__cnt >= 0); \
 111     __failed = __failed || pdfContext->fObjectStack.count() == 0; \
 112     if (pdfContext->fObjectStack.count() > 0) { \
 113         SkPdfNativeObject* tmp = pdfContext->fObjectStack.top(); \
 114         pdfContext->fObjectStack.pop(); \
 115         if (!tmp || !tmp->isNumber()) { \
 116             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, \
 117                                       __operator_name, \
 118                                       tmp, \
 119                                       SkPdfNativeObject::kInteger_PdfObjectType | \
 120                                           SkPdfNativeObject::kReal_PdfObjectType, \
 121                                       NULL);\
 122             __failed = true;\
 123         } else { \
 124             var = tmp->numberValue(); \
 125         } \
 126     }
 127
 128
 129 #define POP_NAME(pdfContext,name) \
 130     SkDEBUGCODE(__cnt--); \
 131     SkASSERT(__cnt >= 0); \
 132     SkPdfNativeObject* name = NULL; \
 133     __failed = __failed || pdfContext->fObjectStack.count() == 0; \
 134     if (pdfContext->fObjectStack.count() > 0) { \
 135         SkPdfNativeObject* tmp = pdfContext->fObjectStack.top(); \
 136         pdfContext->fObjectStack.pop(); \
 137         if (!tmp || !tmp->isName()) { \
 138             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, \
 139                                       __operator_name, \
 140                                       tmp, \
 141                                       SkPdfNativeObject::kName_PdfObjectType, \
 142                                       NULL);\
 143             __failed = true;\
 144         } else { \
 145             name = tmp; \
 146         } \
 147     }
 148
 149 #define POP_STRING(pdfContext,name) \
 150     SkDEBUGCODE(__cnt--); \
 151     SkASSERT(__cnt >= 0); \
 152     SkPdfNativeObject* name = NULL; \
 153     __failed = __failed || pdfContext->fObjectStack.count() == 0; \
 154     if (pdfContext->fObjectStack.count() > 0) { \
 155         SkPdfNativeObject* tmp = pdfContext->fObjectStack.top(); \
 156         pdfContext->fObjectStack.pop(); \
 157         if (!tmp || !tmp->isAnyString()) { \
 158             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, \
 159                                       __operator_name, \
 160                                       tmp, \
 161                                       SkPdfNativeObject::kString_PdfObjectType | \
 162                                           SkPdfNativeObject::kHexString_PdfObjectType, \
 163                                       NULL);\
 164             __failed = true;\
 165         } else { \
 166             name = tmp; \
 167         } \
 168     }
 169
 170 #define POP_ARRAY(pdfContext,name) \
 171     SkDEBUGCODE(__cnt--); \
 172     SkASSERT(__cnt >= 0); \
 173     SkPdfArray* name = NULL; \
 174     __failed = __failed || pdfContext->fObjectStack.count() == 0; \
 175     if (pdfContext->fObjectStack.count() > 0) { \
 176         SkPdfNativeObject* tmp = pdfContext->fObjectStack.top(); \
 177         pdfContext->fObjectStack.pop(); \
 178         if (!tmp || !tmp->isArray()) { \
 179             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, \
 180                                       __operator_name, \
 181                                       tmp, \
 182                                       SkPdfNativeObject::kArray_PdfObjectType, \
 183                                       NULL);\
 184             __failed = true;\
 185         } else { \
 186             name = (SkPdfArray*)tmp; \
 187         } \
 188     }
 189
 190 #define CHECK_PARAMETERS() \
 191     SkASSERT(__cnt == 0); \
 192     if (__failed) return kIgnoreError_SkPdfResult;
 193
 194
 195 NotOwnedString strings_DeviceRGB;
 196 NotOwnedString strings_DeviceCMYK;
 197
 198 class StringsInit {
 199 public:
 200     StringsInit() {
 201         NotOwnedString::init(&strings_DeviceRGB, "DeviceRGB");
 202         NotOwnedString::init(&strings_DeviceCMYK, "DeviceCMYK");
 203     }
 204 };
 205
 206 // TODO(edisonn): this will not work in chrome! Find another solution!
 207 StringsInit gStringsInit;
 208
 209 // TODO(edisonn): Document SkPdfTokenLooper and subclasses.
 210 class PdfInlineImageLooper : public SkPdfTokenLooper {
 211 public:
 212     explicit PdfInlineImageLooper(SkPdfTokenLooper* parent)
 213         : INHERITED(parent) {}
 214
 215     SkPdfResult consumeToken(PdfToken& token) override;
 216     void loop() override;
 217
 218 private:
 219     typedef SkPdfTokenLooper INHERITED;
 220 };
 221
 222 class PdfCompatibilitySectionLooper : public SkPdfTokenLooper {
 223 public:
 224     explicit PdfCompatibilitySectionLooper(SkPdfTokenLooper* parent)
 225         : INHERITED (parent) {}
 226
 227     SkPdfResult consumeToken(PdfToken& token) override;
 228     void loop() override;
 229
 230 private:
 231     typedef SkPdfTokenLooper INHERITED;
 232 };
 233
 234 // Utilities
 235 static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color = SK_ColorWHITE) {
 236     bitmap->allocN32Pixels(width, height);
 237     bitmap->eraseColor(color);
 238 }
 239
 240 // TODO(edisonn): synonyms? /DeviceRGB and /RGB mean the same thing. Context dependent.
 241 static int GetColorSpaceComponents(NotOwnedString& colorSpace) {
 242     if (colorSpace.equals("DeviceCMYK")) {
 243         return 4;
 244     } else if (colorSpace.equals("DeviceGray") ||
 245             colorSpace.equals("CalGray") ||
 246             colorSpace.equals("Indexed")) {
 247         return 1;
 248     } else if (colorSpace.equals("DeviceRGB") ||
 249             colorSpace.equals("CalRGB") ||
 250             colorSpace.equals("Lab")) {
 251         return 3;
 252     } else {
 253         return 0;
 254     }
 255 }
 256
 257 SkMatrix SkMatrixFromPdfMatrix(double array[6]) {
 258     SkMatrix matrix;
 259     matrix.setAll(SkDoubleToScalar(array[0]),
 260                   SkDoubleToScalar(array[2]),
 261                   SkDoubleToScalar(array[4]),
 262                   SkDoubleToScalar(array[1]),
 263                   SkDoubleToScalar(array[3]),
 264                   SkDoubleToScalar(array[5]),
 265                   SkDoubleToScalar(0),
 266                   SkDoubleToScalar(0),
 267                   SkDoubleToScalar(1));
 268
 269     return matrix;
 270 }
 271
 272 SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray) {
 273     double array[6];
 274
 275     // TODO(edisonn): security issue, ret if size() != 6
 276     if (pdfArray == NULL) {
 277         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue,
 278                     "null array passed to build matrix", NULL, NULL);
 279         return SkMatrix::I();
 280     }
 281
 282     if (pdfArray->size() != 6) {
 283         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kUnexpectedArraySize_SkPdfIssue,
 284                     "null array passed to build matrix", pdfArray, NULL);
 285         return SkMatrix::I();
 286     }
 287
 288     for (int i = 0; i < 6; i++) {
 289         const SkPdfNativeObject* elem = pdfArray->operator [](i);
 290         if (elem == NULL || !elem->isNumber()) {
 291             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, elem,
 292                                       SkPdfNativeObject::_kNumber_PdfObjectType, NULL);
 293             return SkMatrix::I();
 294         }
 295         array[i] = elem->numberValue();
 296     }
 297
 298     return SkMatrixFromPdfMatrix(array);
 299 }
 300
 301 // TODO(edisonn): debug code, used to analyze rendering when we find bugs.
 302 extern "C" SkPdfNativeDoc* gDoc;
 303
 304 static SkPdfResult DrawText(SkPdfContext* pdfContext,
 305                    const SkPdfNativeObject* _str,
 306                    SkCanvas* canvas)
 307 {
 308     SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont;
 309     if (skfont == NULL) {
 310         skfont = SkPdfFont::Default();
 311     }
 312
 313     if (_str == NULL || !_str->isAnyString()) {
 314         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity,
 315                                   "DrawText",
 316                                   _str,
 317                                   SkPdfNativeObject::_kAnyString_PdfObjectType,
 318                                   pdfContext);
 319         return kIgnoreError_SkPdfResult;
 320     }
 321     const SkPdfString* str = (const SkPdfString*)_str;
 322
 323     SkUnencodedText binary(str);
 324
 325     SkDecodedText decoded;
 326
 327     if (skfont->encoding() == NULL) {
 328         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingEncoding_SkPdfIssue,
 329                     "draw text", _str, pdfContext);
 330         return kNYI_SkPdfResult;
 331     }
 332
 333     skfont->encoding()->decodeText(binary, &decoded);
 334
 335     SkPaint paint;
 336     // TODO(edisonn): does size 0 mean anything special?
 337     if (pdfContext->fGraphicsState.fCurFontSize != 0) {
 338         paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize));
 339     }
 340
 341     // TODO(edisonn): implement font scaler
 342 //    if (fCurFont && fCurFont->GetFontScale() != 0) {
 343 //        paint.setTextScaleX(fCurFont->GetFontScale() / 100.0);
 344 //    }
 345
 346     pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
 347
 348     skfont->drawText(decoded, &paint, pdfContext, canvas);
 349
 350     return kOK_SkPdfResult;
 351 }
 352
 353 // TODO(edisonn): create header files with declarations!
 354 SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper* parentLooper);
 355 SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper* parentLooper);
 356 SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper* parentLooper);
 357 SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper* parentLooper);
 358
 359 // TODO(edisonn): perf!!!
 360 static SkColorTable* getGrayColortable() {
 361     static SkColorTable* grayColortable = NULL;
 362     if (grayColortable == NULL) {
 363         SkPMColor* colors = new SkPMColor[256];
 364         for (int i = 0 ; i < 256; i++) {
 365             colors[i] = SkPreMultiplyARGB(255, i, i, i);
 366         }
 367         grayColortable = new SkColorTable(colors, 256);
 368     }
 369     return grayColortable;
 370 }
 371
 372 static SkBitmap* transferImageStreamToBitmap(const unsigned char* uncompressedStream,
 373                                              size_t uncompressedStreamLength,
 374                                              int width, int height, int bytesPerLine,
 375                                              int bpc, const SkString& colorSpace,
 376                                              bool transparencyMask) {
 377     SkBitmap* bitmap = new SkBitmap();
 378
 379     //int components = GetColorSpaceComponents(colorSpace);
 380 //#define MAX_COMPONENTS 10
 381
 382     // TODO(edisonn): assume start of lines are aligned at 32 bits?
 383     // Is there a faster way to load the uncompressed stream into a bitmap?
 384
 385     // minimal support for now
 386     if ((colorSpace.equals("DeviceRGB") || colorSpace.equals("RGB")) && bpc == 8) {
 387         uint32_t* uncompressedStreamArgb = (SkColor*)malloc(width * height * sizeof(uint32_t));
 388
 389         for (int h = 0 ; h < height; h++) {
 390             long i = width * (h);
 391             for (int w = 0 ; w < width; w++) {
 392                 uncompressedStreamArgb[i] = SkPackARGB32(0xFF,
 393                                                          uncompressedStream[3 * w],
 394                                                          uncompressedStream[3 * w + 1],
 395                                                          uncompressedStream[3 * w + 2]);
 396                 i++;
 397             }
 398             uncompressedStream += bytesPerLine;
 399         }
 400
 401         const SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
 402         bitmap->installPixels(info, uncompressedStreamArgb, info.minRowBytes());
 403     }
 404     else if ((colorSpace.equals("DeviceGray") || colorSpace.equals("Gray")) && bpc == 8) {
 405         unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height);
 406
 407         for (int h = 0 ; h < height; h++) {
 408             long i = width * (h);
 409             for (int w = 0 ; w < width; w++) {
 410                 uncompressedStreamA8[i] = transparencyMask ? 255 - uncompressedStream[w] :
 411                                                              uncompressedStream[w];
 412                 i++;
 413             }
 414             uncompressedStream += bytesPerLine;
 415         }
 416
 417         const SkColorType ct = transparencyMask ? kAlpha_8_SkColorType : kIndex_8_SkColorType;
 418         const SkImageInfo info = SkImageInfo::Make(width, height, ct, kPremul_SkAlphaType);
 419         bitmap->installPixels(info, uncompressedStreamA8, info.minRowBytes(),
 420                               transparencyMask ? NULL : getGrayColortable(), NULL, NULL);
 421     }
 422
 423     // TODO(edisonn): pass color space and context here?
 424     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "Color space NYI", NULL, NULL);
 425     return bitmap;
 426 }
 427 // TODO(edisonn): preserve A1 format that skia knows, + fast convert from 111, 222, 444 to closest
 428 // skia format.
 429
 430 // This functions returns the image, it does not look at the smask.
 431 static SkBitmap* getImageFromObjectCore(SkPdfContext* pdfContext,
 432                                         SkPdfImageDictionary* image, bool transparencyMask) {
 433     if (image == NULL || !image->hasStream()) {
 434         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "Missing stream", image,
 435                                   SkPdfNativeObject::_kStream_PdfObjectType, pdfContext);
 436         return NULL;
 437     }
 438
 439     int bpc = (int)image->BitsPerComponent(pdfContext->fPdfDoc);
 440     int width = (int)image->Width(pdfContext->fPdfDoc);
 441     int height = (int)image->Height(pdfContext->fPdfDoc);
 442     SkString colorSpace("DeviceRGB");
 443
 444     bool indexed = false;
 445     SkPMColor colors[256];
 446     int cnt = 0;
 447
 448     if (image->isColorSpaceAName(pdfContext->fPdfDoc)) {
 449         colorSpace = image->getColorSpaceAsName(pdfContext->fPdfDoc);
 450     } else if (image->isColorSpaceAArray(pdfContext->fPdfDoc)) {
 451         SkPdfArray* array = image->getColorSpaceAsArray(pdfContext->fPdfDoc);
 452         if (array && array->size() == 4 && array->objAtAIndex(0)->isName("Indexed") &&
 453                                            (array->objAtAIndex(1)->isName("DeviceRGB") ||
 454                                                    array->objAtAIndex(1)->isName("RGB")) &&
 455                                            array->objAtAIndex(2)->isInteger() &&
 456                                            array->objAtAIndex(3)->isHexString()
 457                                            ) {
 458             SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "Color space NYI",
 459                         image, pdfContext);
 460             indexed = true;
 461             cnt = (int)array->objAtAIndex(2)->intValue() + 1;
 462             if (cnt > 256) {
 463                 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue,
 464                             "Color space feature NYI, cnt > 256", image, pdfContext);
 465                 return NULL;
 466             }
 467             NotOwnedString data = array->objAtAIndex(3)->strRef();
 468             if (data.fBytes != (unsigned int)cnt * 3) {
 469                 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kIncostistentSizes_SkPdfIssue,
 470                             "Image color table mismatch color space specs", array, pdfContext);
 471                 return NULL;
 472             }
 473             for (int i = 0 ; i < cnt; i++) {
 474                 colors[i] = SkPreMultiplyARGB(0xff,
 475                                               data.fBuffer[3 * i],
 476                                               data.fBuffer[3 * i + 1],
 477                                               data.fBuffer[3 * i + 2]);
 478             }
 479         }
 480     }
 481
 482     //  TODO(edisonn): implement image masks.
 483 /*  bool imageMask = image->imageMask();
 484     if (imageMask) {
 485         if (bpc != 0 && bpc != 1) {
 486             // TODO(edisonn): report warning to be used in testing.
 487             return SkBitmap();
 488         }
 489         bpc = 1;
 490     }
 491 */
 492
 493     const unsigned char* uncompressedStream = NULL;
 494     size_t uncompressedStreamLength = 0;
 495
 496     SkPdfStream* stream = (SkPdfStream*)image;
 497
 498     if (!stream || !stream->GetFilteredStreamRef(&uncompressedStream, &uncompressedStreamLength) ||
 499             uncompressedStream == NULL || uncompressedStreamLength == 0) {
 500         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "Missing stream", stream,
 501                                   SkPdfNativeObject::_kStream_PdfObjectType, pdfContext);
 502         return NULL;
 503     }
 504
 505     SkPdfStreamCommonDictionary* streamDict = (SkPdfStreamCommonDictionary*)stream;
 506
 507     if (streamDict->has_Filter() &&
 508             ((streamDict->isFilterAName(NULL) &&
 509                   streamDict->getFilterAsName(NULL).equals("DCTDecode")) ||
 510              (streamDict->isFilterAArray(NULL) &&
 511                   streamDict->getFilterAsArray(NULL)->size() > 0 &&
 512                   streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->isName() &&
 513                   streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->nameValue2()
 514                                                                     .equals("DCTDecode")))) {
 515         SkBitmap* bitmap = new SkBitmap();
 516         SkImageDecoder::DecodeMemory(uncompressedStream, uncompressedStreamLength, bitmap);
 517         return bitmap;
 518     }
 519
 520     // TODO(edisonn): assumes RGB for now, since it is the only one implemented
 521     if (indexed) {
 522         SkBitmap* bitmap = new SkBitmap();
 523         const SkImageInfo info = SkImageInfo::Make(width, height, kIndex_8_SkColorType,
 524                                                    kPremul_SkAlphaType);
 525         SkAutoTUnref<SkColorTable> colorTable(new SkColorTable(colors, cnt));
 526         bitmap->installPixels(info, (void*)uncompressedStream, info.minRowBytes(), colorTable,
 527                               NULL, NULL);
 528         return bitmap;
 529     }
 530
 531     int bytesPerLine = (int)(uncompressedStreamLength / height);
 532 #ifdef PDF_TRACE
 533     if (uncompressedStreamLength % height != 0) {
 534         printf("Warning uncompressedStreamLength modulo height != 0 !!!\n");
 535     }
 536 #endif
 537
 538     SkBitmap* bitmap = transferImageStreamToBitmap(
 539             (unsigned char*)uncompressedStream, uncompressedStreamLength,
 540             (int)width, (int)height, bytesPerLine,
 541             (int)bpc, colorSpace,
 542             transparencyMask);
 543
 544     return bitmap;
 545 }
 546
 547 static SkBitmap* getImageFromObject(SkPdfContext* pdfContext, SkPdfImageDictionary* image,
 548                                     bool transparencyMask) {
 549     if (!transparencyMask) {
 550         if (!image->hasData(SkPdfNativeObject::kBitmap_Data)) {
 551             SkBitmap* bitmap = getImageFromObjectCore(pdfContext, image, transparencyMask);
 552             image->setData(bitmap, SkPdfNativeObject::kBitmap_Data);
 553         }
 554         return (SkBitmap*) image->data(SkPdfNativeObject::kBitmap_Data);
 555     } else {
 556         return getImageFromObjectCore(pdfContext, image, transparencyMask);
 557     }
 558 }
 559
 560 static SkBitmap* getSmaskFromObject(SkPdfContext* pdfContext, SkPdfImageDictionary* obj) {
 561     SkPdfImageDictionary* sMask = obj->SMask(pdfContext->fPdfDoc);
 562
 563     if (sMask) {
 564         return getImageFromObject(pdfContext, sMask, true);
 565     }
 566
 567     // TODO(edisonn): implement GS SMask. Default to empty right now.
 568     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue,
 569                 "implement GS SMask. Default to empty right now.", obj, pdfContext);
 570
 571     return pdfContext->fGraphicsState.fSMask;
 572 }
 573
 574 static SkPdfResult doXObject_Image(SkPdfContext* pdfContext, SkCanvas* canvas,
 575                                    SkPdfImageDictionary* skpdfimage) {
 576     if (skpdfimage == NULL) {
 577         return kIgnoreError_SkPdfResult;
 578     }
 579
 580     SkBitmap* image = getImageFromObject(pdfContext, skpdfimage, false);
 581     SkBitmap* sMask = getSmaskFromObject(pdfContext, skpdfimage);
 582
 583     canvas->save();
 584     canvas->setMatrix(pdfContext->fGraphicsState.fCTM);
 585
 586     SkScalar z = SkIntToScalar(0);
 587     SkScalar one = SkIntToScalar(1);
 588
 589     SkPoint from[4] = {SkPoint::Make(z, z), SkPoint::Make(one, z),
 590                        SkPoint::Make(one, one), SkPoint::Make(z, one)};
 591     SkPoint to[4] = {SkPoint::Make(z, one), SkPoint::Make(one, one),
 592                      SkPoint::Make(one, z), SkPoint::Make(z, z)};
 593     SkMatrix flip;
 594     SkAssertResult(flip.setPolyToPoly(from, to, 4));
 595     SkMatrix solveImageFlip = pdfContext->fGraphicsState.fCTM;
 596     solveImageFlip.preConcat(flip);
 597     canvas->setMatrix(solveImageFlip);
 598
 599 #ifdef PDF_TRACE
 600     SkPoint final[4] = {SkPoint::Make(z, z), SkPoint::Make(one, z),
 601                         SkPoint::Make(one, one), SkPoint::Make(z, one)};
 602     solveImageFlip.mapPoints(final, 4);
 603     printf("IMAGE rect = ");
 604     for (int i = 0; i < 4; i++) {
 605         printf("(%f %f) ", SkScalarToDouble(final[i].x()), SkScalarToDouble(final[i].y()));
 606     }
 607     printf("\n");
 608 #endif  // PDF_TRACE
 609
 610     SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0),
 611                                   SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
 612
 613     // TODO(edisonn): soft mask type? alpha/luminosity.
 614     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue,
 615                 "implement soft mask type", skpdfimage, pdfContext);
 616
 617     SkPaint paint;
 618     pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
 619
 620     if (!sMask || sMask->empty()) {
 621         canvas->drawBitmapRect(*image, dst, &paint);
 622     } else {
 623         canvas->saveLayer(&dst, &paint);
 624         canvas->drawBitmapRect(*image, dst, NULL);
 625         SkPaint xfer;
 626         xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode);
 627         canvas->drawBitmapRect(*sMask, dst, &xfer);
 628         canvas->restore();
 629     }
 630
 631     canvas->restore();
 632
 633     return kPartial_SkPdfResult;
 634 }
 635
 636 //TODO(edisonn): options for implementing isolation and knockout
 637 // 1) emulate them (current solution)
 638 //     PRO: simple
 639 //     CON: will need to use readPixels, which means serious perf issues
 640 // 2) Compile a plan for an array of matrixes, compose the result at the end
 641 //     PRO: might be faster then 1, no need to readPixels
 642 //     CON: multiple drawings (but on smaller areas), pay a price at loading pdf to
 643 //          compute a pdf draw plan
 644 //          on average, a load with empty draw is 100ms on all the skps we have, for complete sites
 645 // 3) support them natively in SkCanvas
 646 //     PRO: simple
 647 //     CON: we would still need to use a form of readPixels anyway, so perf might be the same as 1)
 648 // 4) compile a plan using pathops, and render once without any fancy rules with backdrop
 649 //     PRO: simple, fast
 650 //     CON: pathops must be bug free first + time to compute new paths
 651 //          pay a price at loading pdf to compute a pdf draw plan
 652 //          on average, a load with empty draw is 100ms on all the skps we have, for complete sites
 653 // 5) for knockout, render the objects in reverse order, and add every object to the clip, and any
 654 //          new draw will be cliped
 655
 656 static void doGroup_before(SkPdfContext* pdfContext, SkCanvas* canvas, SkRect bbox,
 657                            SkPdfTransparencyGroupDictionary* tgroup, bool page) {
 658     SkRect bboxOrig = bbox;
 659     SkBitmap backdrop;
 660     bool isolatedGroup = tgroup->I(pdfContext->fPdfDoc);
 661 //  bool knockoutGroup = tgroup->K(pdfContext->fPdfDoc);
 662     SkPaint paint;
 663     pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
 664     canvas->saveLayer(&bboxOrig, isolatedGroup ? &paint : NULL);
 665 }
 666
 667 // TODO(edisonn): non isolation should probably be implemented in skia
 668 //static void doGroup_after(SkPdfContext* pdfContext, SkCanvas* canvas, SkRect bbox,
 669 //                          SkPdfTransparencyGroupDictionary* tgroup) {
 670 //    if not isolated
 671 //        canvas->drawBitmapRect(backdrop, bboxOrig, NULL);
 672 //}
 673
 674 static SkPdfResult doXObject_Form(SkPdfContext* pdfContext, SkCanvas* canvas,
 675                                   SkPdfType1FormDictionary* skobj) {
 676     if (!skobj || !skobj->hasStream()) {
 677         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "Missing stream", skobj,
 678                                   SkPdfNativeObject::_kStream_PdfObjectType, pdfContext);
 679         return kIgnoreError_SkPdfResult;
 680     }
 681
 682     if (!skobj->has_BBox()) {
 683         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingRequiredKey_SkPdfIssue, "BBox",
 684                     skobj, pdfContext);
 685         return kIgnoreError_SkPdfResult;
 686     }
 687
 688     PdfOp_q(pdfContext, canvas, NULL);
 689
 690
 691     if (skobj->Resources(pdfContext->fPdfDoc)) {
 692         pdfContext->fGraphicsState.fResources = skobj->Resources(pdfContext->fPdfDoc);
 693     }
 694
 695     SkTraceMatrix(pdfContext->fGraphicsState.fCTM, "Current matrix");
 696
 697     if (skobj->has_Matrix()) {
 698         pdfContext->fGraphicsState.fCTM.preConcat(skobj->Matrix(pdfContext->fPdfDoc));
 699         SkMatrix matrix = pdfContext->fGraphicsState.fCTM;
 700         matrix.preScale(SkDoubleToScalar(1), SkDoubleToScalar(-1));
 701         pdfContext->fGraphicsState.fMatrixTm = matrix;
 702         pdfContext->fGraphicsState.fMatrixTlm = matrix;
 703         // TODO(edisonn): text matrixes mosltly NYI
 704     }
 705
 706     SkTraceMatrix(pdfContext->fGraphicsState.fCTM, "Total matrix");
 707     pdfContext->fGraphicsState.fContentStreamMatrix = pdfContext->fGraphicsState.fCTM;
 708
 709     canvas->setMatrix(pdfContext->fGraphicsState.fCTM);
 710
 711     SkRect bbox = skobj->BBox(pdfContext->fPdfDoc);
 712     // TODO(edisonn): constants (AA) from settings.
 713     canvas->clipRect(bbox, SkRegion::kIntersect_Op, false);
 714
 715     // This is a group?
 716     if (skobj->has_Group()) {
 717         SkPdfTransparencyGroupDictionary* tgroup = skobj->Group(pdfContext->fPdfDoc);
 718         doGroup_before(pdfContext, canvas, bbox, tgroup, false);
 719     }
 720
 721     SkPdfStream* stream = (SkPdfStream*)skobj;
 722
 723     pdfContext->parseStream(stream, canvas);
 724
 725     if (skobj->has_Group()) {
 726         canvas->restore();
 727     }
 728
 729     PdfOp_Q(pdfContext, canvas, NULL);
 730     return kPartial_SkPdfResult;
 731 }
 732
 733 static SkPdfResult doXObject_Pattern(SkPdfContext* pdfContext, SkCanvas* canvas,
 734                                      SkPdfType1PatternDictionary* skobj) {
 735     if (!skobj || !skobj->hasStream()) {
 736         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "Missing stream",
 737                                   skobj, SkPdfNativeObject::_kStream_PdfObjectType, pdfContext);
 738         return kIgnoreError_SkPdfResult;
 739     }
 740
 741     if (!skobj->has_BBox()) {
 742         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingRequiredKey_SkPdfIssue, "BBox",
 743                     skobj, pdfContext);
 744         return kIgnoreError_SkPdfResult;
 745     }
 746
 747     PdfOp_q(pdfContext, canvas, NULL);
 748
 749
 750     if (skobj->Resources(pdfContext->fPdfDoc)) {
 751         pdfContext->fGraphicsState.fResources = skobj->Resources(pdfContext->fPdfDoc);
 752     }
 753
 754     SkTraceMatrix(pdfContext->fGraphicsState.fContentStreamMatrix, "Current Content stream matrix");
 755
 756     if (skobj->has_Matrix()) {
 757         pdfContext->fGraphicsState.fContentStreamMatrix.preConcat(
 758                 skobj->Matrix(pdfContext->fPdfDoc));
 759     }
 760
 761     SkTraceMatrix(pdfContext->fGraphicsState.fContentStreamMatrix, "Total Content stream matrix");
 762
 763     canvas->setMatrix(pdfContext->fGraphicsState.fContentStreamMatrix);
 764     pdfContext->fGraphicsState.fCTM = pdfContext->fGraphicsState.fContentStreamMatrix;
 765
 766     SkRect bbox = skobj->BBox(pdfContext->fPdfDoc);
 767     // TODO(edisonn): constants (AA) from settings.
 768     canvas->clipRect(bbox, SkRegion::kIntersect_Op, false);
 769
 770     SkPdfStream* stream = (SkPdfStream*)skobj;
 771
 772     pdfContext->parseStream(stream, canvas);
 773
 774     PdfOp_Q(pdfContext, canvas, NULL);
 775     return kPartial_SkPdfResult;
 776 }
 777
 778 // TODO(edisonn): PS NYI
 779 //static SkPdfResult doXObject_PS(SkPdfContext* pdfContext, SkCanvas* canvas,
 780 //                                const SkPdfNativeObject* obj) {
 781 //    return kNYI_SkPdfResult;
 782 //}
 783
 784 SkPdfResult doType3Char(SkPdfContext* pdfContext, SkCanvas* canvas, const SkPdfNativeObject* skobj,
 785                         SkRect bBox, SkMatrix matrix, double textSize) {
 786     if (!skobj || !skobj->hasStream()) {
 787         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "Missing stream", skobj,
 788                                   SkPdfNativeObject::_kStream_PdfObjectType, pdfContext);
 789         return kIgnoreError_SkPdfResult;
 790     }
 791
 792     PdfOp_q(pdfContext, canvas, NULL);
 793
 794     pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
 795     pdfContext->fGraphicsState.fMatrixTm.preScale(SkDoubleToScalar(textSize),
 796                                                   SkDoubleToScalar(textSize));
 797     pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrixTm;
 798
 799     pdfContext->fGraphicsState.fCTM = pdfContext->fGraphicsState.fMatrixTm;
 800     pdfContext->fGraphicsState.fCTM.preScale(SkDoubleToScalar(1), SkDoubleToScalar(-1));
 801
 802     SkTraceMatrix(pdfContext->fGraphicsState.fCTM, "Total matrix");
 803
 804     canvas->setMatrix(pdfContext->fGraphicsState.fCTM);
 805
 806     SkRect rm = bBox;
 807     pdfContext->fGraphicsState.fCTM.mapRect(&rm);
 808
 809     SkTraceRect(rm, "bbox mapped");
 810
 811     // TODO(edisonn): constants (AA) from settings.
 812     canvas->clipRect(bBox, SkRegion::kIntersect_Op, false);
 813
 814     SkPdfStream* stream = (SkPdfStream*)skobj;
 815
 816     pdfContext->parseStream(stream, canvas);
 817
 818     PdfOp_Q(pdfContext, canvas, NULL);
 819
 820     return kPartial_SkPdfResult;
 821 }
 822
 823 // The PDF could be corrupted so a dict refers recursively to the same dict, if this happens
 824 // we end up with a stack overflow and crash.
 825 class CheckRecursiveRendering {
 826     SkPdfNativeObject* fObj;
 827 public:
 828     CheckRecursiveRendering(SkPdfNativeObject* obj) : fObj(obj) {
 829         SkASSERT(!obj->inRendering());
 830         obj->startRendering();
 831     }
 832
 833     ~CheckRecursiveRendering() {
 834         SkASSERT(fObj->inRendering());
 835         fObj->doneRendering();
 836     }
 837
 838     static bool IsInRendering(const SkPdfNativeObject* obj) {
 839         return obj->inRendering();
 840     }
 841 };
 842
 843 static SkPdfResult doXObject(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfNativeObject* obj) {
 844     if (CheckRecursiveRendering::IsInRendering(obj)) {
 845         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kRecursiveReferencing_SkPdfIssue,
 846                     "Recursive reverencing is invalid in draw objects", obj, pdfContext);
 847         return kIgnoreError_SkPdfResult;
 848     }
 849
 850     CheckRecursiveRendering checkRecursion(obj);
 851
 852     switch (pdfContext->fPdfDoc->mapper()->mapXObjectDictionary(obj))
 853     {
 854         case kImageDictionary_SkPdfNativeObjectType:
 855             return doXObject_Image(pdfContext, canvas, (SkPdfImageDictionary*)obj);
 856         case kType1FormDictionary_SkPdfNativeObjectType:
 857             return doXObject_Form(pdfContext, canvas, (SkPdfType1FormDictionary*)obj);
 858         //case kObjectDictionaryXObjectPS_SkPdfNativeObjectType:
 859             //return doXObject_PS(skxobj.asPS());
 860         default: {
 861             if (pdfContext->fPdfDoc->mapper()->mapType1PatternDictionary(obj) !=
 862                     kNone_SkPdfNativeObjectType) {
 863                 SkPdfType1PatternDictionary* pattern = (SkPdfType1PatternDictionary*)obj;
 864                 return doXObject_Pattern(pdfContext, canvas, pattern);
 865             }
 866             SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "doXObject",
 867                         obj, pdfContext);
 868         }
 869     }
 870     return kIgnoreError_SkPdfResult;
 871 }
 872
 873 static SkPdfResult doPage(SkPdfContext* pdfContext, SkCanvas* canvas,
 874                           SkPdfPageObjectDictionary* skobj) {
 875     if (!skobj || !skobj->isContentsAStream(pdfContext->fPdfDoc)) {
 876         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "Missing stream", skobj,
 877                                   SkPdfNativeObject::_kStream_PdfObjectType, pdfContext);
 878         return kNYI_SkPdfResult;
 879     }
 880
 881     SkPdfStream* stream = skobj->getContentsAsStream(pdfContext->fPdfDoc);
 882
 883     if (!stream) {
 884         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "Missing stream",
 885                                   skobj, SkPdfNativeObject::_kStream_PdfObjectType, pdfContext);
 886         return kIgnoreError_SkPdfResult;
 887     }
 888
 889     // FIXME (scroggo): renderPage also sets fResources. Are these redundant?
 890     pdfContext->fGraphicsState.fResources = skobj->Resources(pdfContext->fPdfDoc);
 891
 892     if (!pdfContext->fGraphicsState.fResources) {
 893         // It might be null because we have not implemented yet inheritance.
 894         return kIgnoreError_SkPdfResult;
 895     }
 896
 897     if (CheckRecursiveRendering::IsInRendering(skobj)) {
 898         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kRecursiveReferencing_SkPdfIssue,
 899                     "Recursive reverencing is invalid in draw objects", skobj, pdfContext);
 900         return kIgnoreError_SkPdfResult;
 901     }
 902     CheckRecursiveRendering checkRecursion(skobj);
 903
 904
 905     // FIXME (scroggo): Is this save necessary? May be needed for rendering a nested PDF.
 906     PdfOp_q(pdfContext, canvas, NULL);
 907
 908     // TODO(edisonn): MediaBox can be inherited!!!!
 909     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "MediaBox inheritance NYI",
 910                 NULL, pdfContext);
 911     SkRect bbox = skobj->MediaBox(pdfContext->fPdfDoc);
 912     if (skobj->has_Group()) {
 913         SkPdfTransparencyGroupDictionary* tgroup = skobj->Group(pdfContext->fPdfDoc);
 914         doGroup_before(pdfContext, canvas, bbox, tgroup, true);
 915     } else {
 916         canvas->save();
 917     }
 918
 919     pdfContext->parseStream(stream, canvas);
 920
 921     canvas->restore();
 922     PdfOp_Q(pdfContext, canvas, NULL);
 923     return kPartial_SkPdfResult;
 924 }
 925
 926 SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
 927     pdfContext->fStateStack.push(pdfContext->fGraphicsState);
 928     canvas->save();
 929     pdfContext->fObjectStack.nest();
 930     return kOK_SkPdfResult;
 931 }
 932
 933 SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
 934     if (pdfContext->fStateStack.count() > 0) {
 935         pdfContext->fGraphicsState = pdfContext->fStateStack.top();
 936         pdfContext->fStateStack.pop();
 937         canvas->restore();
 938
 939         if (pdfContext->fObjectStack.nestingLevel() == 0) {
 940             SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kStackNestingOverflow_SkPdfIssue,
 941                         "stack nesting overflow (q/Q)", NULL, pdfContext);
 942             return kIgnoreError_SkPdfResult;
 943         } else {
 944             pdfContext->fObjectStack.unnest();
 945         }
 946     } else {
 947         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kStackOverflow_SkPdfIssue,
 948                     "stack overflow (q/Q)", NULL, pdfContext);
 949         return kIgnoreError_SkPdfResult;
 950     }
 951
 952     return kOK_SkPdfResult;
 953 }
 954
 955 static SkPdfResult PdfOp_cm(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
 956     EXPECT_OPERANDS("cm", pdfContext, 6);
 957     POP_NUMBER(pdfContext, f);
 958     POP_NUMBER(pdfContext, e);
 959     POP_NUMBER(pdfContext, d);
 960     POP_NUMBER(pdfContext, c);
 961     POP_NUMBER(pdfContext, b);
 962     POP_NUMBER(pdfContext, a);
 963     CHECK_PARAMETERS();
 964     double array[6] = {a, b, c, d, e, f};
 965
 966     // a b
 967     // c d
 968     // e f
 969
 970     // 0 1
 971     // 2 3
 972     // 4 5
 973
 974     // sx ky
 975     // kx sy
 976     // tx ty
 977     SkMatrix matrix = SkMatrixFromPdfMatrix(array);
 978
 979     pdfContext->fGraphicsState.fCTM.preConcat(matrix);
 980
 981 #ifdef PDF_TRACE
 982     printf("cm ");
 983     for (int i = 0 ; i < 6 ; i++) {
 984         printf("%f ", array[i]);
 985     }
 986     printf("\n");
 987     SkTraceMatrix(pdfContext->fGraphicsState.fCTM, "cm");
 988 #endif
 989
 990     return kOK_SkPdfResult;
 991 }
 992
 993 //leading TL Set the text leading, Tl
 994 //, to leading, which is a number expressed in unscaled text
 995 //space units. Text leading is used only by the T*, ', and " operators. Initial value: 0.
 996 static SkPdfResult PdfOp_TL(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
 997     EXPECT_OPERANDS("TL", pdfContext, 1);
 998     POP_NUMBER(pdfContext, ty);
 999     CHECK_PARAMETERS();
1000
1001     pdfContext->fGraphicsState.fTextLeading = ty;
1002
1003     return kOK_SkPdfResult;
1004 }
1005
1006 static SkPdfResult PdfOp_Td(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1007     EXPECT_OPERANDS("Td", pdfContext, 2);
1008     POP_NUMBER(pdfContext, ty);
1009     POP_NUMBER(pdfContext, tx);
1010     CHECK_PARAMETERS();
1011
1012     double array[6] = {1, 0, 0, 1, tx, -ty};
1013     SkMatrix matrix = SkMatrixFromPdfMatrix(array);
1014
1015     pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
1016     pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix);
1017
1018     return kPartial_SkPdfResult;
1019 }
1020
1021 static SkPdfResult PdfOp_TD(SkPdfContext* pdfContext, SkCanvas* canvas,
1022                             SkPdfTokenLooper* parentLooper) {
1023     EXPECT_OPERANDS("TD", pdfContext, 2)
1024     POP_NUMBER(pdfContext, ty);
1025     POP_NUMBER(pdfContext, tx);
1026     CHECK_PARAMETERS();
1027
1028     // TODO(edisonn): Create factory methods or constructors so native is hidden
1029     SkPdfReal* _ty = pdfContext->fPdfDoc->createReal(-ty);
1030     pdfContext->fObjectStack.push(_ty);
1031
1032     PdfOp_TL(pdfContext, canvas, parentLooper);
1033
1034     SkPdfReal* vtx = pdfContext->fPdfDoc->createReal(tx);
1035     pdfContext->fObjectStack.push(vtx);
1036
1037     SkPdfReal* vty = pdfContext->fPdfDoc->createReal(ty);
1038     pdfContext->fObjectStack.push(vty);
1039
1040     SkPdfResult ret = PdfOp_Td(pdfContext, canvas, parentLooper);
1041
1042     return ret;
1043 }
1044
1045 static SkPdfResult PdfOp_Tm(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1046     EXPECT_OPERANDS("Tm", pdfContext, 6);
1047     POP_NUMBER(pdfContext, f);
1048     POP_NUMBER(pdfContext, e);
1049     POP_NUMBER(pdfContext, d);
1050     POP_NUMBER(pdfContext, c);
1051     POP_NUMBER(pdfContext, b);
1052     POP_NUMBER(pdfContext, a);
1053     CHECK_PARAMETERS();
1054
1055     double array[6];
1056     array[0] = a;
1057     array[1] = b;
1058     array[2] = c;
1059     array[3] = d;
1060     array[4] = e;
1061     array[5] = f;
1062
1063     SkMatrix matrix = SkMatrixFromPdfMatrix(array);
1064     matrix.postConcat(pdfContext->fGraphicsState.fCTM);
1065     matrix.preScale(SkDoubleToScalar(1), SkDoubleToScalar(-1));
1066
1067     // TODO(edisonn): NYI - Text positioning.
1068     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue,
1069                 "Text positioning not implemented for 2+ chars", NULL, pdfContext);
1070
1071     pdfContext->fGraphicsState.fMatrixTm = matrix;
1072     pdfContext->fGraphicsState.fMatrixTlm = matrix;;
1073
1074     return kPartial_SkPdfResult;
1075 }
1076
1077 //— T* Move to the start of the next line. This operator has the same effect as the code
1078 //0 Tl Td
1079 //where Tl is the current leading parameter in the text state
1080 static SkPdfResult PdfOp_T_star(SkPdfContext* pdfContext, SkCanvas* canvas,
1081                                 SkPdfTokenLooper* parentLooper) {
1082     SkPdfReal* zero = pdfContext->fPdfDoc->createReal(0.0);
1083     SkPdfReal* tl = pdfContext->fPdfDoc->createReal(pdfContext->fGraphicsState.fTextLeading);
1084
1085     pdfContext->fObjectStack.push(zero);
1086     pdfContext->fObjectStack.push(tl);
1087
1088     SkPdfResult ret = PdfOp_Td(pdfContext, canvas, parentLooper);
1089
1090     return ret;
1091 }
1092
1093 static SkPdfResult PdfOp_m(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1094     if (pdfContext->fGraphicsState.fPathClosed) {
1095         pdfContext->fGraphicsState.fPath.reset();
1096         pdfContext->fGraphicsState.fPathClosed = false;
1097     }
1098
1099     EXPECT_OPERANDS("m", pdfContext, 2);
1100     POP_NUMBER(pdfContext, y);
1101     POP_NUMBER(pdfContext, x);
1102     CHECK_PARAMETERS();
1103
1104     pdfContext->fGraphicsState.fCurPosY = y;
1105     pdfContext->fGraphicsState.fCurPosX = x;
1106
1107     pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
1108                                             SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
1109
1110     return kOK_SkPdfResult;
1111 }
1112
1113 static SkPdfResult PdfOp_l(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1114     if (pdfContext->fGraphicsState.fPathClosed) {
1115         pdfContext->fGraphicsState.fPath.reset();
1116         pdfContext->fGraphicsState.fPathClosed = false;
1117     }
1118
1119     EXPECT_OPERANDS("l", pdfContext, 2);
1120     POP_NUMBER(pdfContext, y);
1121     POP_NUMBER(pdfContext, x);
1122     CHECK_PARAMETERS();
1123
1124     pdfContext->fGraphicsState.fCurPosY = y;
1125     pdfContext->fGraphicsState.fCurPosX = x;
1126
1127     pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX),
1128                                             SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY));
1129
1130     return kOK_SkPdfResult;
1131 }
1132
1133 static SkPdfResult PdfOp_c(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1134     if (pdfContext->fGraphicsState.fPathClosed) {
1135         pdfContext->fGraphicsState.fPath.reset();
1136         pdfContext->fGraphicsState.fPathClosed = false;
1137     }
1138
1139     EXPECT_OPERANDS("c", pdfContext, 6);
1140     POP_NUMBER(pdfContext, y3);
1141     POP_NUMBER(pdfContext, x3);
1142     POP_NUMBER(pdfContext, y2);
1143     POP_NUMBER(pdfContext, x2);
1144     POP_NUMBER(pdfContext, y1);
1145     POP_NUMBER(pdfContext, x1);
1146     CHECK_PARAMETERS();
1147
1148     pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
1149                                              SkDoubleToScalar(x2), SkDoubleToScalar(y2),
1150                                              SkDoubleToScalar(x3), SkDoubleToScalar(y3));
1151
1152     pdfContext->fGraphicsState.fCurPosX = x3;
1153     pdfContext->fGraphicsState.fCurPosY = y3;
1154
1155     return kOK_SkPdfResult;
1156 }
1157
1158 static SkPdfResult PdfOp_v(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1159     if (pdfContext->fGraphicsState.fPathClosed) {
1160         pdfContext->fGraphicsState.fPath.reset();
1161         pdfContext->fGraphicsState.fPathClosed = false;
1162     }
1163
1164     EXPECT_OPERANDS("v", pdfContext, 4);
1165     POP_NUMBER(pdfContext, y3);
1166     POP_NUMBER(pdfContext, x3);
1167     POP_NUMBER(pdfContext, y2);
1168     POP_NUMBER(pdfContext, x2);
1169     CHECK_PARAMETERS();
1170
1171     double y1 = pdfContext->fGraphicsState.fCurPosY;
1172     double x1 = pdfContext->fGraphicsState.fCurPosX;
1173
1174     pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
1175                                              SkDoubleToScalar(x2), SkDoubleToScalar(y2),
1176                                              SkDoubleToScalar(x3), SkDoubleToScalar(y3));
1177
1178     pdfContext->fGraphicsState.fCurPosX = x3;
1179     pdfContext->fGraphicsState.fCurPosY = y3;
1180
1181     return kOK_SkPdfResult;
1182 }
1183
1184 static SkPdfResult PdfOp_y(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1185     if (pdfContext->fGraphicsState.fPathClosed) {
1186         pdfContext->fGraphicsState.fPath.reset();
1187         pdfContext->fGraphicsState.fPathClosed = false;
1188     }
1189
1190     EXPECT_OPERANDS("y", pdfContext, 4);
1191     POP_NUMBER(pdfContext, y3);
1192     POP_NUMBER(pdfContext, x3);
1193     POP_NUMBER(pdfContext, y1);
1194     POP_NUMBER(pdfContext, x1);
1195     CHECK_PARAMETERS();
1196
1197     double y2 = pdfContext->fGraphicsState.fCurPosY;
1198     double x2 = pdfContext->fGraphicsState.fCurPosX;
1199
1200     pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1),
1201                                              SkDoubleToScalar(x2), SkDoubleToScalar(y2),
1202                                              SkDoubleToScalar(x3), SkDoubleToScalar(y3));
1203
1204     pdfContext->fGraphicsState.fCurPosX = x3;
1205     pdfContext->fGraphicsState.fCurPosY = y3;
1206
1207     return kOK_SkPdfResult;
1208 }
1209
1210 static SkPdfResult PdfOp_re(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1211     if (pdfContext->fGraphicsState.fPathClosed) {
1212         pdfContext->fGraphicsState.fPath.reset();
1213         pdfContext->fGraphicsState.fPathClosed = false;
1214     }
1215
1216     EXPECT_OPERANDS("re", pdfContext, 4);
1217     POP_NUMBER(pdfContext, height);
1218     POP_NUMBER(pdfContext, width);
1219     POP_NUMBER(pdfContext, y);
1220     POP_NUMBER(pdfContext, x);
1221     CHECK_PARAMETERS();
1222
1223     pdfContext->fGraphicsState.fPath.addRect(SkDoubleToScalar(x),
1224                                              SkDoubleToScalar(y),
1225                                              SkDoubleToScalar(x + width),
1226                                              SkDoubleToScalar(y + height));
1227
1228     pdfContext->fGraphicsState.fCurPosX = x;
1229     pdfContext->fGraphicsState.fCurPosY = y + height;
1230
1231     return kOK_SkPdfResult;
1232 }
1233
1234 static SkPdfResult PdfOp_h(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1235     pdfContext->fGraphicsState.fPath.close();
1236     return kOK_SkPdfResult;
1237 }
1238
1239 static SkPdfResult PdfOp_fillAndStroke(SkPdfContext* pdfContext, SkCanvas* canvas,
1240                                        bool fill, bool stroke, bool close, bool evenOdd) {
1241     SkPath path = pdfContext->fGraphicsState.fPath;
1242
1243     if (close) {
1244         path.close();
1245     }
1246
1247     canvas->setMatrix(pdfContext->fGraphicsState.fCTM);
1248
1249     SkPaint paint;
1250
1251     SkPoint line[2];
1252     if (fill && !stroke && path.isLine(line)) {
1253         paint.setStyle(SkPaint::kStroke_Style);
1254
1255         // TODO(edisonn): implement this with patterns
1256         pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
1257         paint.setStrokeWidth(SkDoubleToScalar(0));
1258
1259         canvas->drawPath(path, paint);
1260     } else {
1261         if (fill) {
1262             if (strncmp((char*)pdfContext->fGraphicsState.fNonStroking.fColorSpace.fBuffer,
1263                         "Pattern", strlen("Pattern")) == 0 &&
1264                 pdfContext->fGraphicsState.fNonStroking.fPattern != NULL) {
1265
1266                 // TODO(edisonn): we can use a shader here, like imageshader to draw fast.
1267
1268                 PdfOp_q(pdfContext, canvas, NULL);
1269
1270                 if (evenOdd) {
1271                     path.setFillType(SkPath::kEvenOdd_FillType);
1272                 }
1273                 canvas->clipPath(path);
1274
1275                 if (pdfContext->fPdfDoc
1276                               ->mapper()
1277                               ->mapType1PatternDictionary(pdfContext->fGraphicsState
1278                                                                     .fNonStroking
1279                                                                     .fPattern)
1280                                                          != kNone_SkPdfNativeObjectType) {
1281                     SkPdfType1PatternDictionary* pattern
1282                             = (SkPdfType1PatternDictionary*)pdfContext->fGraphicsState
1283                                                                       .fNonStroking
1284                                                                       .fPattern;
1285
1286                     // TODO(edisonn): make PaintType constants
1287                     if (pattern->PaintType(pdfContext->fPdfDoc) == 1) {
1288                         // TODO(edisonn): don't use abs, iterate as asked, if the cells intersect
1289                         // it will change the result iterating in reverse
1290                         // remove then the following  bounds.sort();
1291                         int xStep = abs((int)pattern->XStep(pdfContext->fPdfDoc));
1292                         int yStep = abs((int)pattern->YStep(pdfContext->fPdfDoc));
1293
1294                         SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue,
1295                                     "paterns x/y step is forced to positive number",
1296                                     pattern, pdfContext);
1297
1298                         SkRect bounds = path.getBounds();
1299                         bounds.sort();
1300
1301                         SkScalar x;
1302                         SkScalar y;
1303
1304                         y = bounds.top();
1305                         int totalx = 0;
1306                         int totaly = 0;
1307                         while (y < bounds.bottom()) {
1308                             x = bounds.left();
1309                             totalx = 0;
1310
1311                             while (x < bounds.right()) {
1312                                 doXObject(pdfContext, canvas, pattern);
1313
1314                                 pdfContext->fGraphicsState.fContentStreamMatrix.preTranslate(
1315                                         SkIntToScalar(xStep), SkIntToScalar(0));
1316                                 totalx += xStep;
1317                                 x += SkIntToScalar(xStep);
1318                             }
1319                             pdfContext->fGraphicsState.fContentStreamMatrix.preTranslate(
1320                                     SkIntToScalar(-totalx), SkIntToScalar(0));
1321
1322                             pdfContext->fGraphicsState.fContentStreamMatrix.preTranslate(
1323                                     SkIntToScalar(0), SkIntToScalar(-yStep));
1324                             totaly += yStep;
1325                             y += SkIntToScalar(yStep);
1326                         }
1327                         pdfContext->fGraphicsState.fContentStreamMatrix.preTranslate(
1328                                 SkIntToScalar(0), SkIntToScalar(totaly));
1329                     }
1330                 }
1331
1332                 PdfOp_Q(pdfContext, canvas, NULL);
1333             } else {
1334                 paint.setStyle(SkPaint::kFill_Style);
1335                 if (evenOdd) {
1336                     path.setFillType(SkPath::kEvenOdd_FillType);
1337                 }
1338
1339                 pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
1340
1341                 canvas->drawPath(path, paint);
1342             }
1343         }
1344
1345         if (stroke) {
1346             if (false && strncmp((char*)pdfContext->fGraphicsState.fNonStroking.fColorSpace.fBuffer,
1347                                  "Pattern", strlen("Pattern")) == 0) {
1348                 // TODO(edisonn): implement Pattern for strokes
1349                 paint.setStyle(SkPaint::kStroke_Style);
1350
1351                 paint.setColor(SK_ColorGREEN);
1352
1353                 // reset it, just in case it messes up the stroke
1354                 path.setFillType(SkPath::kWinding_FillType);
1355                 canvas->drawPath(path, paint);
1356             } else {
1357                 paint.setStyle(SkPaint::kStroke_Style);
1358
1359                 pdfContext->fGraphicsState.applyGraphicsState(&paint, true);
1360
1361                 // reset it, just in case it messes up the stroke
1362                 path.setFillType(SkPath::kWinding_FillType);
1363                 canvas->drawPath(path, paint);
1364             }
1365         }
1366     }
1367
1368     pdfContext->fGraphicsState.fPath.reset();
1369     // TODO(edisonn): implement scale/zoom
1370
1371     if (pdfContext->fGraphicsState.fHasClipPathToApply) {
1372 #ifndef PDF_DEBUG_NO_CLIPING
1373         canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
1374 #endif
1375     }
1376
1377     //pdfContext->fGraphicsState.fClipPath.reset();
1378     pdfContext->fGraphicsState.fHasClipPathToApply = false;
1379
1380     return kOK_SkPdfResult;
1381
1382 }
1383
1384 static SkPdfResult PdfOp_S(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1385     return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false);
1386 }
1387
1388 static SkPdfResult PdfOp_s(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1389     return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false);
1390 }
1391
1392 static SkPdfResult PdfOp_F(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1393     return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
1394 }
1395
1396 static SkPdfResult PdfOp_f(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1397     return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false);
1398 }
1399
1400 static SkPdfResult PdfOp_f_star(SkPdfContext* pdfContext, SkCanvas* canvas,
1401                                 SkPdfTokenLooper*) {
1402     return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true);
1403 }
1404
1405 static SkPdfResult PdfOp_B(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1406     return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false);
1407 }
1408
1409 static SkPdfResult PdfOp_B_star(SkPdfContext* pdfContext, SkCanvas* canvas,
1410                                 SkPdfTokenLooper*) {
1411     return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true);
1412 }
1413
1414 static SkPdfResult PdfOp_b(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1415     return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false);
1416 }
1417
1418 static SkPdfResult PdfOp_b_star(SkPdfContext* pdfContext, SkCanvas* canvas,
1419                                 SkPdfTokenLooper*) {
1420     return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true);
1421 }
1422
1423 static SkPdfResult PdfOp_n(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1424     canvas->setMatrix(pdfContext->fGraphicsState.fCTM);
1425     if (pdfContext->fGraphicsState.fHasClipPathToApply) {
1426 #ifndef PDF_DEBUG_NO_CLIPING
1427         canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true);
1428 #endif
1429     }
1430
1431     pdfContext->fGraphicsState.fHasClipPathToApply = false;
1432
1433     pdfContext->fGraphicsState.fPathClosed = true;
1434
1435     return kOK_SkPdfResult;
1436 }
1437
1438 static SkPdfResult PdfOp_BT(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1439     pdfContext->fGraphicsState.fTextBlock   = true;
1440     SkMatrix matrix = pdfContext->fGraphicsState.fCTM;
1441     matrix.preScale(SkDoubleToScalar(1), SkDoubleToScalar(-1));
1442     pdfContext->fGraphicsState.fMatrixTm = matrix;
1443     pdfContext->fGraphicsState.fMatrixTlm = matrix;
1444
1445     return kPartial_SkPdfResult;
1446 }
1447
1448 static SkPdfResult PdfOp_ET(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1449     if (!pdfContext->fGraphicsState.fTextBlock) {
1450         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "ET without BT", NULL,
1451                     pdfContext);
1452
1453         return kIgnoreError_SkPdfResult;
1454     }
1455
1456     pdfContext->fGraphicsState.fTextBlock = false;
1457
1458     // TODO(edisonn): anything else to be done once we are done with draw text? Like restore stack?
1459     return kOK_SkPdfResult;
1460 }
1461
1462 static SkPdfResult skpdfGraphicsStateApplyFontCore(SkPdfContext* pdfContext,
1463                                                    const SkPdfNativeObject* fontName, double fontSize) {
1464 #ifdef PDF_TRACE
1465     printf("font name: %s\n", fontName->nameValue2().c_str());
1466 #endif
1467
1468     if (!pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)) {
1469         // TODO(edisonn): try to recover and draw it any way?
1470         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingFont_SkPdfIssue,
1471                     "No font", fontName, pdfContext);
1472         return kIgnoreError_SkPdfResult;
1473     }
1474
1475     SkPdfNativeObject* objFont
1476             = pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)->get(fontName);
1477     objFont = pdfContext->fPdfDoc->resolveReference(objFont);
1478     if (kNone_SkPdfNativeObjectType == pdfContext->fPdfDoc->mapper()->mapFontDictionary(objFont)) {
1479         // TODO(edisonn): try to recover and draw it any way?
1480         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kInvalidFont_SkPdfIssue,
1481                     "Invalid font", objFont, pdfContext);
1482         return kIgnoreError_SkPdfResult;
1483     }
1484
1485     SkPdfFontDictionary* fd = (SkPdfFontDictionary*)objFont;
1486
1487     SkPdfFont* skfont = SkPdfFont::fontFromPdfDictionary(pdfContext->fPdfDoc, fd);
1488
1489     if (skfont) {
1490         pdfContext->fGraphicsState.fSkFont = skfont;
1491     }
1492     pdfContext->fGraphicsState.fCurFontSize = fontSize;
1493     return kOK_SkPdfResult;
1494 }
1495
1496 //font size Tf Set the text font, Tf
1497 //, to font and the text font size, Tfs, to size. font is the name of a
1498 //font resource in the Fontsubdictionary of the current resource dictionary; size is
1499 //a number representing a scale factor. There is no initial value for either font or
1500 //size; they must be speciﬁed explicitly using Tf before any text is shown.
1501 static SkPdfResult PdfOp_Tf(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1502     EXPECT_OPERANDS("Tf", pdfContext, 2);
1503     POP_NUMBER(pdfContext, fontSize);
1504     POP_NAME(pdfContext, fontName);
1505     CHECK_PARAMETERS();
1506
1507     return skpdfGraphicsStateApplyFontCore(pdfContext, fontName, fontSize);
1508 }
1509
1510 static SkPdfResult PdfOp_Tj(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1511     EXPECT_OPERANDS("Tj", pdfContext, 1);
1512     POP_STRING(pdfContext, str);
1513     CHECK_PARAMETERS();
1514
1515     if (!pdfContext->fGraphicsState.fTextBlock) {
1516         // TODO(edisonn): try to recover and draw it any way?
1517         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "Tj without BT", NULL,
1518                     pdfContext);
1519         return kIgnoreError_SkPdfResult;
1520     }
1521
1522     SkPdfResult ret = DrawText(pdfContext, str, canvas);
1523
1524     return ret;
1525 }
1526
1527 static SkPdfResult PdfOp_quote(SkPdfContext* pdfContext, SkCanvas* canvas,
1528                                SkPdfTokenLooper* parentLooper) {
1529     if (!pdfContext->fGraphicsState.fTextBlock) {
1530         // TODO(edisonn): try to recover and draw it any way?
1531         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue,
1532                     "' without BT", NULL, pdfContext);
1533         return kIgnoreError_SkPdfResult;
1534     }
1535
1536     PdfOp_T_star(pdfContext, canvas, parentLooper);
1537     // Do not pop, and push, just transfer the param to Tj
1538     return PdfOp_Tj(pdfContext, canvas, parentLooper);
1539 }
1540
1541 static SkPdfResult PdfOp_doublequote(SkPdfContext* pdfContext, SkCanvas* canvas,
1542                                      SkPdfTokenLooper* parentLooper) {
1543     if (!pdfContext->fGraphicsState.fTextBlock) {
1544         // TODO(edisonn): try to recover and draw it any way?
1545         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue,
1546                     "\" without BT", NULL, pdfContext);
1547         return kIgnoreError_SkPdfResult;
1548     }
1549
1550     EXPECT_OPERANDS("\"", pdfContext, 3);
1551     POP_OBJ(pdfContext, str);
1552     POP_OBJ(pdfContext, ac);
1553     POP_OBJ(pdfContext, aw);
1554     CHECK_PARAMETERS();
1555
1556     pdfContext->fObjectStack.push(aw);
1557     PdfOp_Tw(pdfContext, canvas, parentLooper);
1558
1559     pdfContext->fObjectStack.push(ac);
1560     PdfOp_Tc(pdfContext, canvas, parentLooper);
1561
1562     pdfContext->fObjectStack.push(str);
1563     PdfOp_quote(pdfContext, canvas, parentLooper);
1564
1565     return kPartial_SkPdfResult;
1566 }
1567
1568 static SkPdfResult PdfOp_TJ(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1569     EXPECT_OPERANDS("Tf", pdfContext, 1);
1570     POP_ARRAY(pdfContext, array);
1571     CHECK_PARAMETERS();
1572
1573     if (!pdfContext->fGraphicsState.fTextBlock) {
1574         // TODO(edisonn): try to recover and draw it any way?
1575         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "TJ without BT", NULL,
1576                     pdfContext);
1577         return kIgnoreError_SkPdfResult;
1578     }
1579
1580     if (!array->isArray()) {
1581         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, array,
1582                                   SkPdfNativeObject::kArray_PdfObjectType, pdfContext);
1583         return kIgnoreError_SkPdfResult;
1584     }
1585
1586     for( int i=0; i<static_cast<int>(array->size()); i++ )
1587     {
1588         if (!(*array)[i]) {
1589             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity,
1590                                       "element [i] is null, no element should be null",
1591                                       array,
1592                                       SkPdfNativeObject::_kAnyString_PdfObjectType |
1593                                               SkPdfNativeObject::_kNumber_PdfObjectType,
1594                                       pdfContext);
1595         } else if( (*array)[i]->isAnyString()) {
1596             SkPdfNativeObject* obj = (*array)[i];
1597             DrawText(pdfContext, obj, canvas);
1598         } else if ((*array)[i]->isNumber()) {
1599             double dx = (*array)[i]->numberValue();
1600             SkMatrix matrix;
1601             matrix.setAll(SkDoubleToScalar(1),
1602                           SkDoubleToScalar(0),
1603                           // TODO(edisonn): use writing mode, vertical/horizontal.
1604                           SkDoubleToScalar(-dx),  // amount is substracted!!!
1605                           SkDoubleToScalar(0),
1606                           SkDoubleToScalar(1),
1607                           SkDoubleToScalar(0),
1608                           SkDoubleToScalar(0),
1609                           SkDoubleToScalar(0),
1610                           SkDoubleToScalar(1));
1611
1612             pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
1613         } else {
1614             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "wrong type", (*array)[i],
1615                                       SkPdfNativeObject::kArray_PdfObjectType |
1616                                               SkPdfNativeObject::_kNumber_PdfObjectType,
1617                                       pdfContext);
1618         }
1619     }
1620     return kPartial_SkPdfResult;  // TODO(edisonn): Implement fully DrawText before returing OK.
1621 }
1622
1623 static SkPdfResult PdfOp_CS_cs(SkPdfContext* pdfContext, SkCanvas* canvas,
1624                                SkPdfColorOperator* colorOperator) {
1625     EXPECT_OPERANDS("CS/cs", pdfContext, 1);
1626     POP_NAME(pdfContext, name);
1627     CHECK_PARAMETERS();
1628
1629     //Next, get the ColorSpace Dictionary from the Resource Dictionary:
1630     SkPdfDictionary* colorSpaceResource
1631             = pdfContext->fGraphicsState.fResources->ColorSpace(pdfContext->fPdfDoc);
1632
1633     SkPdfNativeObject* colorSpace
1634             = colorSpaceResource ? pdfContext->fPdfDoc
1635                                              ->resolveReference(colorSpaceResource->get(name)) :
1636                                    name;
1637
1638     if (colorSpace == NULL) {
1639         colorOperator->fColorSpace = name->strRef();
1640     } else {
1641 #ifdef PDF_TRACE
1642         printf("CS = %s\n", colorSpace->toString(0, 0).c_str());
1643 #endif   // PDF_TRACE
1644         if (colorSpace->isName()) {
1645             colorOperator->fColorSpace = colorSpace->strRef();
1646         } else if (colorSpace->isArray()) {
1647             size_t cnt = colorSpace->size();
1648             if (cnt == 0) {
1649                 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kIncostistentSizes_SkPdfIssue,
1650                             "color space has length 0", colorSpace, pdfContext);
1651                 return kIgnoreError_SkPdfResult;
1652             }
1653             SkPdfNativeObject* type = colorSpace->objAtAIndex(0);
1654             type = pdfContext->fPdfDoc->resolveReference(type);
1655
1656             if (type->isName("ICCBased")) {
1657                 if (cnt != 2) {
1658                     SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kIncostistentSizes_SkPdfIssue,
1659                                 "ICCBased color space must have an array with 2 elements",
1660                                 colorSpace, pdfContext);
1661                     return kIgnoreError_SkPdfResult;
1662                 }
1663                 SkPdfNativeObject* prop = colorSpace->objAtAIndex(1);
1664                 prop = pdfContext->fPdfDoc->resolveReference(prop);
1665 #ifdef PDF_TRACE
1666                 printf("ICCBased prop = %s\n", prop->toString(0, 0).c_str());
1667 #endif   // PDF_TRACE
1668                 // TODO(edisonn): hack
1669                 if (prop && prop->isDictionary() && prop->get("N") &&
1670                         prop->get("N")->isInteger() && prop->get("N")->intValue() == 3) {
1671                     colorOperator->setColorSpace(&strings_DeviceRGB);
1672                     return kPartial_SkPdfResult;
1673                 }
1674                 return kNYI_SkPdfResult;
1675             }
1676         }
1677     }
1678
1679     return kPartial_SkPdfResult;
1680 }
1681
1682 static SkPdfResult PdfOp_CS(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1683     return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
1684 }
1685
1686 static SkPdfResult PdfOp_cs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1687     return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
1688 }
1689
1690 static SkPdfResult PdfOp_SC_sc(SkPdfContext* pdfContext, SkCanvas* canvas,
1691                                SkPdfColorOperator* colorOperator) {
1692     double c[4];
1693 //    int64_t v[4];
1694
1695     int n = GetColorSpaceComponents(colorOperator->fColorSpace);
1696
1697     bool doubles = true;
1698     if (colorOperator->fColorSpace.equals("Indexed")) {
1699         doubles = false;
1700     }
1701
1702 #ifdef PDF_TRACE
1703     printf("color space = %s, N = %i\n", colorOperator->fColorSpace.fBuffer, n);
1704 #endif
1705
1706     EXPECT_OPERANDS("SC/sc", pdfContext, n);
1707
1708     for (int i = n - 1; i >= 0 ; i--) {
1709         if (doubles) {
1710             POP_NUMBER_INTO(pdfContext, c[i]);
1711 //        } else {
1712 //            v[i] = pdfContext->fObjectStack.top()->intValue();        pdfContext->fObjectStack.pop();
1713         }
1714     }
1715     CHECK_PARAMETERS();
1716
1717     // TODO(edisonn): Now, set that color. Only DeviceRGB supported.
1718     // TODO(edisonn): do possible field values to enum at parsing time!
1719     // TODO(edisonn): support also abbreviations /DeviceRGB == /RGB
1720     if (colorOperator->fColorSpace.equals("DeviceRGB") ||
1721             colorOperator->fColorSpace.equals("RGB")) {
1722         colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*c[0]),
1723                                                  (U8CPU)(255*c[1]),
1724                                                  (U8CPU)(255*c[2])));
1725     }
1726     return kPartial_SkPdfResult;
1727 }
1728
1729 static SkPdfResult PdfOp_SC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1730     return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
1731 }
1732
1733 static SkPdfResult PdfOp_sc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1734     return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
1735 }
1736
1737 static SkPdfResult PdfOp_SCN_scn(SkPdfContext* pdfContext, SkCanvas* canvas,
1738                                  SkPdfColorOperator* colorOperator) {
1739     if (pdfContext->fObjectStack.count() > 0 && pdfContext->fObjectStack.top()->isName()) {
1740         SkPdfNativeObject* name = pdfContext->fObjectStack.top();    pdfContext->fObjectStack.pop();
1741
1742         SkPdfDictionary* patternResources
1743                 = pdfContext->fGraphicsState.fResources->Pattern(pdfContext->fPdfDoc);
1744
1745         if (patternResources == NULL) {
1746 #ifdef PDF_TRACE
1747             printf("ExtGState is NULL!\n");
1748 #endif
1749             return kIgnoreError_SkPdfResult;
1750         }
1751
1752         colorOperator->setPatternColorSpace(
1753                 pdfContext->fPdfDoc->resolveReference(patternResources->get(name)));
1754     }
1755
1756     // TODO(edisonn): SCN supports more color spaces than SCN. Read and implement spec.
1757     PdfOp_SC_sc(pdfContext, canvas, colorOperator);
1758
1759     return kPartial_SkPdfResult;
1760 }
1761
1762 static SkPdfResult PdfOp_SCN(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1763     return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
1764 }
1765
1766 static SkPdfResult PdfOp_scn(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1767     return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
1768 }
1769
1770 static SkPdfResult PdfOp_G_g(SkPdfContext* pdfContext, SkCanvas* canvas,
1771                              SkPdfColorOperator* colorOperator) {
1772     EXPECT_OPERANDS("G/g", pdfContext, 1);
1773     POP_NUMBER(pdfContext, gray);
1774     CHECK_PARAMETERS();
1775
1776     // TODO(edisonn): limit gray in [0, 1]
1777
1778     // TODO(edisonn): HACK - it should be device gray, but not suported right now
1779     colorOperator->fColorSpace = strings_DeviceRGB;
1780     colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255 * gray),
1781                                              (U8CPU)(255 * gray),
1782                                              (U8CPU)(255 * gray)));
1783
1784     return kPartial_SkPdfResult;
1785 }
1786
1787 static SkPdfResult PdfOp_G(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1788     return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
1789 }
1790
1791 static SkPdfResult PdfOp_g(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1792     return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
1793 }
1794
1795 static SkPdfResult PdfOp_RG_rg(SkPdfContext* pdfContext, SkCanvas* canvas,
1796                                SkPdfColorOperator* colorOperator) {
1797     EXPECT_OPERANDS("RG/rg", pdfContext, 3);
1798     POP_NUMBER(pdfContext, b);
1799     POP_NUMBER(pdfContext, g);
1800     POP_NUMBER(pdfContext, r);
1801     CHECK_PARAMETERS();
1802
1803     colorOperator->fColorSpace = strings_DeviceRGB;
1804     colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*r), (U8CPU)(255*g), (U8CPU)(255*b)));
1805     return kOK_SkPdfResult;
1806 }
1807
1808 static SkPdfResult PdfOp_RG(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1809     return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
1810 }
1811
1812 static SkPdfResult PdfOp_rg(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1813     return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
1814 }
1815
1816 static SkPdfResult PdfOp_K_k(SkPdfContext* pdfContext, SkCanvas* canvas,
1817                              SkPdfColorOperator* colorOperator) {
1818     // TODO(edisonn): spec has some rules about overprint, implement them.
1819     EXPECT_OPERANDS("K/k", pdfContext, 4);
1820     POP_NUMBER(pdfContext, k);
1821     POP_NUMBER(pdfContext, y);
1822     POP_NUMBER(pdfContext, m);
1823     POP_NUMBER(pdfContext, c);
1824     CHECK_PARAMETERS();
1825
1826     // TODO(edisonn): really silly quick way to remove compiler warning
1827     if (k + y + m + c == 0) {
1828         return kNYI_SkPdfResult;
1829     }
1830
1831     //colorOperator->fColorSpace = strings_DeviceCMYK;
1832     // TODO(edisonn): Set color.
1833     return kNYI_SkPdfResult;
1834 }
1835
1836 static SkPdfResult PdfOp_K(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1837     return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking);
1838 }
1839
1840 static SkPdfResult PdfOp_k(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1841     return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking);
1842 }
1843
1844 static SkPdfResult PdfOp_W(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1845     pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
1846     pdfContext->fGraphicsState.fHasClipPathToApply = true;
1847
1848     return kOK_SkPdfResult;
1849 }
1850
1851 static SkPdfResult PdfOp_W_star(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1852     pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath;
1853
1854     pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType);
1855     pdfContext->fGraphicsState.fHasClipPathToApply = true;
1856
1857     return kOK_SkPdfResult;
1858 }
1859
1860 static SkPdfResult PdfOp_BX(SkPdfContext* pdfContext, SkCanvas* canvas,
1861                             SkPdfTokenLooper* parentLooper) {
1862     PdfCompatibilitySectionLooper looper(parentLooper);
1863     looper.loop();
1864     return kOK_SkPdfResult;
1865 }
1866
1867 static SkPdfResult PdfOp_EX(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1868     SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue,
1869                 "EX operator should not be called, it is handled in a looper, "
1870                         "unless the file is corrupted, we should assert",
1871                 NULL, pdfContext);
1872
1873     return kIgnoreError_SkPdfResult;
1874 }
1875
1876 static SkPdfResult PdfOp_BI(SkPdfContext* pdfContext, SkCanvas* canvas,
1877                             SkPdfTokenLooper* parentLooper) {
1878     PdfInlineImageLooper looper(parentLooper);
1879     looper.loop();
1880     return kOK_SkPdfResult;
1881 }
1882
1883 static SkPdfResult PdfOp_ID(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1884     SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue,
1885                 "ID operator should not be called, it is habdled in a looper, "
1886                         "unless the file is corrupted, we should assert",
1887                 NULL, pdfContext);
1888     return kIgnoreError_SkPdfResult;
1889 }
1890
1891 static SkPdfResult PdfOp_EI(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
1892     SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue,
1893                 "EI operator should not be called, it is habdled in a looper, "
1894                         "unless the file is corrupted, we should assert",
1895                 NULL, pdfContext);
1896     return kIgnoreError_SkPdfResult;
1897 }
1898
1899 static SkPdfResult skpdfGraphicsStateApply_ca(SkPdfContext* pdfContext, double ca) {
1900     pdfContext->fGraphicsState.fNonStroking.fOpacity = ca;
1901     return kOK_SkPdfResult;
1902 }
1903
1904 static SkPdfResult skpdfGraphicsStateApply_CA(SkPdfContext* pdfContext, double CA) {
1905     pdfContext->fGraphicsState.fStroking.fOpacity = CA;
1906     return kOK_SkPdfResult;
1907 }
1908
1909 static SkPdfResult skpdfGraphicsStateApplyLW(SkPdfContext* pdfContext, double lineWidth) {
1910     pdfContext->fGraphicsState.fLineWidth = lineWidth;
1911     return kOK_SkPdfResult;
1912 }
1913
1914 static SkPdfResult skpdfGraphicsStateApplyLC(SkPdfContext* pdfContext, int64_t lineCap) {
1915     pdfContext->fGraphicsState.fLineCap = (int)lineCap;
1916     return kOK_SkPdfResult;
1917 }
1918
1919 static SkPdfResult skpdfGraphicsStateApplyLJ(SkPdfContext* pdfContext, int64_t lineJoin) {
1920     pdfContext->fGraphicsState.fLineJoin = (int)lineJoin;
1921     return kOK_SkPdfResult;
1922 }
1923
1924 static SkPdfResult skpdfGraphicsStateApplyML(SkPdfContext* pdfContext, double miterLimit) {
1925     pdfContext->fGraphicsState.fMiterLimit = miterLimit;
1926     return kOK_SkPdfResult;
1927 }
1928
1929 // TODO(edisonn): test all dashing rules, not sure if they work as in skia.
1930 /*
1931 1) [ ] 0 No dash; solid, unbroken lines
1932 2) [3] 0 3 units on, 3 units off, …
1933 3) [2] 1 1 on, 2 off, 2 on, 2 off, …
1934 4) [2 1] 0 2 on, 1 off, 2 on, 1 off, …
1935 5) [3 5] 6 2 off, 3 on, 5 off, 3 on, 5 off, …
1936 6) [2 3] 11 1 on, 3 off, 2 on, 3 off, 2 on, …
1937  */
1938
1939 static SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* intervals,
1940                                             SkPdfNativeObject* phase) {
1941     if (intervals == NULL) {
1942         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, intervals,
1943                                   SkPdfNativeObject::_kNumber_PdfObjectType, pdfContext);
1944         return kIgnoreError_SkPdfResult;
1945     }
1946
1947     if (phase == NULL) {
1948         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, phase,
1949                                   SkPdfNativeObject::_kNumber_PdfObjectType, pdfContext);
1950         return kIgnoreError_SkPdfResult;
1951     }
1952
1953     int cnt = (int) intervals->size();
1954     if (cnt >= 256) {
1955         // TODO(edisonn): alloc memory
1956         SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue,
1957                     "dash array size unssuported, cnt > 256", intervals, pdfContext);
1958         return kIgnoreError_SkPdfResult;
1959     }
1960     for (int i = 0; i < cnt; i++) {
1961         if (!intervals->objAtAIndex(i) || !intervals->objAtAIndex(i)->isNumber()) {
1962             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL,
1963                                       intervals->objAtAIndex(i),
1964                                       SkPdfNativeObject::_kNumber_PdfObjectType, NULL);
1965             return kIgnoreError_SkPdfResult;
1966         }
1967     }
1968
1969     double total = 0;
1970     for (int i = 0 ; i < cnt; i++) {
1971         pdfContext->fGraphicsState.fDashArray[i] = intervals->objAtAIndex(i)->scalarValue();
1972         total += pdfContext->fGraphicsState.fDashArray[i];
1973     }
1974     if (cnt & 1) {
1975         if (cnt == 1) {
1976             pdfContext->fGraphicsState.fDashArray[1] = pdfContext->fGraphicsState.fDashArray[0];
1977             cnt++;
1978         } else {
1979             // TODO(edisonn): report error/warning
1980             return kNYI_SkPdfResult;
1981         }
1982     }
1983     pdfContext->fGraphicsState.fDashArrayLength = cnt;
1984     pdfContext->fGraphicsState.fDashPhase = phase->scalarValue();
1985     if (pdfContext->fGraphicsState.fDashPhase == 0) {
1986         // other rules, changes?
1987         pdfContext->fGraphicsState.fDashPhase = SkDoubleToScalar(total);
1988     }
1989
1990     return kOK_SkPdfResult;
1991 }
1992
1993 static SkPdfResult skpdfGraphicsStateApplyD(SkPdfContext* pdfContext, SkPdfArray* dash) {
1994     if (!dash || dash->isArray()) {
1995         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, dash,
1996                                   SkPdfNativeObject::kArray_PdfObjectType, pdfContext);
1997         return kIgnoreError_SkPdfResult;
1998     }
1999
2000     if (dash->size() != 2) {
2001         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kIncostistentSizes_SkPdfIssue,
2002                     "hash array must have 2 elements", dash, pdfContext);
2003         return kIgnoreError_SkPdfResult;
2004     }
2005
2006     if (!dash->objAtAIndex(0) || !dash->objAtAIndex(0)->isArray()) {
2007         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, dash->objAtAIndex(0),
2008                                   SkPdfNativeObject::kArray_PdfObjectType, pdfContext);
2009         return kIgnoreError_SkPdfResult;
2010     }
2011
2012     if (!dash->objAtAIndex(1) || !dash->objAtAIndex(1)->isNumber()) {
2013         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, dash->objAtAIndex(1),
2014                                   SkPdfNativeObject::_kNumber_PdfObjectType, pdfContext);
2015         return kIgnoreError_SkPdfResult;
2016     }
2017
2018     return skpdfGraphicsStateApplyD(pdfContext, (SkPdfArray*)dash->objAtAIndex(0),
2019                                     dash->objAtAIndex(1));
2020 }
2021
2022 static void skpdfGraphicsStateApplyFont(SkPdfContext* pdfContext, SkPdfArray* fontAndSize) {
2023     if (!fontAndSize || !fontAndSize->isArray()) {
2024         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, fontAndSize,
2025                                   SkPdfNativeObject::kArray_PdfObjectType, pdfContext);
2026         return;
2027     }
2028
2029     if (fontAndSize->size() != 2) {
2030         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kIncostistentSizes_SkPdfIssue,
2031                     "font array must have 2 elements", fontAndSize, pdfContext);
2032         return;
2033     }
2034
2035     if (!fontAndSize->objAtAIndex(0) || !fontAndSize->objAtAIndex(0)->isName()) {
2036         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL,
2037                                   fontAndSize->objAtAIndex(0),
2038                                   SkPdfNativeObject::kName_PdfObjectType, pdfContext);
2039         return;
2040     }
2041
2042
2043     if (!fontAndSize->objAtAIndex(1) || !fontAndSize->objAtAIndex(1)->isNumber()) {
2044         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL,
2045                                   fontAndSize->objAtAIndex(0),
2046                                   SkPdfNativeObject::_kNumber_PdfObjectType, pdfContext);
2047         return;
2048     }
2049
2050     skpdfGraphicsStateApplyFontCore(pdfContext, fontAndSize->objAtAIndex(0),
2051                                     fontAndSize->objAtAIndex(1)->numberValue());
2052 }
2053
2054
2055 //lineWidth w Set the line width in the graphics state (see “Line Width” on page 152).
2056 static SkPdfResult PdfOp_w(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2057     EXPECT_OPERANDS("w", pdfContext, 1);
2058     POP_NUMBER(pdfContext, lw);
2059     CHECK_PARAMETERS();
2060
2061     return skpdfGraphicsStateApplyLW(pdfContext, lw);
2062 }
2063
2064 //lineCap J Set the line cap style in the graphics state (see “Line Cap Style” on page 153).
2065 static SkPdfResult PdfOp_J(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2066     // TODO(edisonn): round/ceil to int?
2067     EXPECT_OPERANDS("J", pdfContext, 1);
2068     POP_NUMBER(pdfContext, lc);
2069     CHECK_PARAMETERS();
2070
2071     return skpdfGraphicsStateApplyLC(pdfContext, (int)lc);
2072 }
2073
2074 //lineJoin j Set the line join style in the graphics state (see “Line Join Style” on page 153).
2075 static SkPdfResult PdfOp_j(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2076     // TODO(edisonn): round/ceil to int?
2077     EXPECT_OPERANDS("j", pdfContext, 1);
2078     POP_NUMBER(pdfContext, lj);
2079     CHECK_PARAMETERS();
2080
2081     return skpdfGraphicsStateApplyLJ(pdfContext, (int)lj);
2082 }
2083
2084 //miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on page 153).
2085 static SkPdfResult PdfOp_M(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2086     EXPECT_OPERANDS("M", pdfContext, 1);
2087     POP_NUMBER(pdfContext, ml);
2088     CHECK_PARAMETERS();
2089     return skpdfGraphicsStateApplyML(pdfContext, ml);
2090 }
2091
2092 //dashArray dashPhase d Set the line dash pattern in the graphics state (see “Line Dash Pattern” on
2093 //page 155).
2094 static SkPdfResult PdfOp_d(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2095     EXPECT_OPERANDS("d", pdfContext, 2);
2096     POP_OBJ(pdfContext, phase);
2097     POP_ARRAY(pdfContext, array);
2098     CHECK_PARAMETERS();
2099
2100     return skpdfGraphicsStateApplyD(pdfContext, array, phase);
2101 }
2102
2103 //intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see “Rendering Intents”
2104 // on page 197).
2105 static SkPdfResult PdfOp_ri(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2106     pdfContext->fObjectStack.pop();
2107
2108     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "render intent NYI", NULL,
2109                 pdfContext);
2110
2111     return kNYI_SkPdfResult;
2112 }
2113
2114 //ﬂatness i Set the ﬂatness tolerance in the graphics state (see Section 6.5.1, “Flatness
2115 //Tolerance”). ﬂatness is a number in the range 0 to 100; a value of 0 speci-
2116 //ﬁes the output device’s default ﬂatness tolerance.
2117 static SkPdfResult PdfOp_i(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2118     EXPECT_OPERANDS("i", pdfContext, 1);
2119     POP_NUMBER(pdfContext, flatness);
2120     CHECK_PARAMETERS();
2121
2122     if (flatness < 0 || flatness > 100) {
2123         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
2124                     "flatness must be a real in [0, 100] range", flatness_obj, pdfContext);
2125         return kIgnoreError_SkPdfResult;
2126     }
2127
2128     return kNYI_SkPdfResult;
2129 }
2130
2131 SkTDict<SkXfermode::Mode> gPdfBlendModes(20);
2132
2133 class InitBlendModes {
2134 public:
2135     InitBlendModes() {
2136         // TODO(edisonn): use the python code generator?
2137         // TABLE 7.2 Standard separable blend modes
2138         gPdfBlendModes.set("Normal", SkXfermode::kSrc_Mode);
2139         gPdfBlendModes.set("Multiply", SkXfermode::kMultiply_Mode);
2140         gPdfBlendModes.set("Screen", SkXfermode::kScreen_Mode);
2141         gPdfBlendModes.set("Overlay", SkXfermode::kOverlay_Mode);
2142         gPdfBlendModes.set("Darken", SkXfermode::kDarken_Mode);
2143         gPdfBlendModes.set("Lighten", SkXfermode::kLighten_Mode);
2144         gPdfBlendModes.set("ColorDodge", SkXfermode::kColorDodge_Mode);
2145         gPdfBlendModes.set("ColorBurn", SkXfermode::kColorBurn_Mode);
2146         gPdfBlendModes.set("HardLight", SkXfermode::kHardLight_Mode);
2147         gPdfBlendModes.set("SoftLight", SkXfermode::kSoftLight_Mode);
2148         gPdfBlendModes.set("Difference", SkXfermode::kDifference_Mode);
2149         gPdfBlendModes.set("Exclusion", SkXfermode::kExclusion_Mode);
2150
2151         // TABLE 7.3 Standard nonseparable blend modes
2152         gPdfBlendModes.set("Hue", SkXfermode::kHue_Mode);
2153         gPdfBlendModes.set("Saturation", SkXfermode::kSaturation_Mode);
2154         gPdfBlendModes.set("Color", SkXfermode::kColor_Mode);
2155         gPdfBlendModes.set("Luminosity", SkXfermode::kLuminosity_Mode);
2156     }
2157 };
2158
2159 InitBlendModes _gDummyInniter;
2160
2161 static SkXfermode::Mode xferModeFromBlendMode(const char* blendMode, size_t len) {
2162     SkXfermode::Mode mode = (SkXfermode::Mode)(SkXfermode::kLastMode + 1);
2163     if (gPdfBlendModes.find(blendMode, len, &mode)) {
2164         return mode;
2165     }
2166
2167     return (SkXfermode::Mode)(SkXfermode::kLastMode + 1);
2168 }
2169
2170 static void skpdfGraphicsStateApplyBM_name(SkPdfContext* pdfContext, const SkString& blendMode) {
2171     SkXfermode::Mode mode = xferModeFromBlendMode(blendMode.c_str(), blendMode.size());
2172     if (mode <= SkXfermode::kLastMode) {
2173         pdfContext->fGraphicsState.fBlendModesLength = 1;
2174         pdfContext->fGraphicsState.fBlendModes[0] = mode;
2175     } else {
2176         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kUnknownBlendMode_SkPdfIssue,
2177                     blendMode.c_str(), NULL, pdfContext);
2178     }
2179 }
2180
2181 static void skpdfGraphicsStateApplyBM_array(SkPdfContext* pdfContext, SkPdfArray* blendModes) {
2182     if (!blendModes || !blendModes->isArray()) {
2183         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, blendModes,
2184                                   SkPdfNativeObject::kArray_PdfObjectType, pdfContext);
2185         return;
2186     }
2187
2188     if (blendModes->size() == 0 || blendModes->size() > 256) {
2189         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kIncostistentSizes_SkPdfIssue,
2190                     "length of blendmodes, 0, is an erro, 256+, is NYI", blendModes, pdfContext);
2191         return;
2192     }
2193
2194     SkXfermode::Mode modes[256];
2195     int cnt = (int) blendModes->size();
2196     for (int i = 0; i < cnt; i++) {
2197         SkPdfNativeObject* name = blendModes->objAtAIndex(i);
2198         if (!name || !name->isName()) {
2199             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, name,
2200                                       SkPdfNativeObject::kName_PdfObjectType, pdfContext);
2201             return;
2202         }
2203         SkXfermode::Mode mode = xferModeFromBlendMode(name->c_str(), name->lenstr());
2204         if (mode > SkXfermode::kLastMode) {
2205             SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kUnknownBlendMode_SkPdfIssue, NULL, name,
2206                         pdfContext);
2207             return;
2208         }
2209     }
2210
2211     pdfContext->fGraphicsState.fBlendModesLength = cnt;
2212     for (int i = 0; i < cnt; i++) {
2213         pdfContext->fGraphicsState.fBlendModes[i] = modes[i];
2214     }
2215 }
2216
2217 static void skpdfGraphicsStateApplySMask_dict(SkPdfContext* pdfContext, SkPdfDictionary* sMask) {
2218     if (!sMask || !sMask->isName()) {
2219         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, sMask,
2220                                   SkPdfNativeObject::kArray_PdfObjectType, pdfContext);
2221         return;
2222     }
2223
2224     if (pdfContext->fPdfDoc->mapper()->mapSoftMaskDictionary(sMask)) {
2225         pdfContext->fGraphicsState.fSoftMaskDictionary = (SkPdfSoftMaskDictionary*)sMask;
2226     } else if (pdfContext->fPdfDoc->mapper()->mapSoftMaskImageDictionary(sMask)) {
2227         SkPdfSoftMaskImageDictionary* smid = (SkPdfSoftMaskImageDictionary*)sMask;
2228         pdfContext->fGraphicsState.fSMask = getImageFromObject(pdfContext, smid, true);
2229     } else {
2230         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity,
2231                                   "Dictionary must be SoftMask, or SoftMaskImage",
2232                                   sMask, SkPdfNativeObject::kDictionary_PdfObjectType, pdfContext);
2233     }
2234 }
2235
2236 static void skpdfGraphicsStateApplySMask_name(SkPdfContext* pdfContext, const SkString& sMask) {
2237     if (sMask.equals("None")) {
2238         pdfContext->fGraphicsState.fSoftMaskDictionary = NULL;
2239         pdfContext->fGraphicsState.fSMask = NULL;
2240         return;
2241     }
2242
2243     SkPdfDictionary* extGStateDictionary
2244             = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfDoc);
2245
2246     if (extGStateDictionary == NULL) {
2247         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingExtGState_SkPdfIssue, NULL,
2248                     pdfContext->fGraphicsState.fResources, pdfContext);
2249         return;
2250     }
2251
2252     SkPdfNativeObject* obj
2253             = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(sMask.c_str()));
2254     if (!obj || !obj->isDictionary()) {
2255         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, obj,
2256                                   SkPdfNativeObject::kDictionary_PdfObjectType, pdfContext);
2257         return;
2258     }
2259
2260     pdfContext->fGraphicsState.fSoftMaskDictionary = NULL;
2261     pdfContext->fGraphicsState.fSMask = NULL;
2262
2263     skpdfGraphicsStateApplySMask_dict(pdfContext, obj->asDictionary());
2264 }
2265
2266 static void skpdfGraphicsStateApplyAIS(SkPdfContext* pdfContext, bool alphaSource) {
2267     pdfContext->fGraphicsState.fAlphaSource = alphaSource;
2268 }
2269
2270
2271 //dictName gs (PDF 1.2) Set the speciﬁed parameters in the graphics state. dictName is
2272 //the name of a graphics state parameter dictionary in the ExtGState subdictionary of the current
2273 //resource dictionary (see the next section).
2274 static SkPdfResult PdfOp_gs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2275     EXPECT_OPERANDS("gs", pdfContext, 1);
2276     POP_NAME(pdfContext, name);
2277     CHECK_PARAMETERS();
2278
2279     SkPdfDictionary* extGStateDictionary
2280             = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfDoc);
2281
2282     if (extGStateDictionary == NULL) {
2283         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingExtGState_SkPdfIssue, NULL,
2284                     pdfContext->fGraphicsState.fResources, pdfContext);
2285         return kIgnoreError_SkPdfResult;
2286     }
2287
2288     SkPdfNativeObject* value
2289             = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(name));
2290
2291     if (kNone_SkPdfNativeObjectType ==
2292                 pdfContext->fPdfDoc->mapper()->mapGraphicsStateDictionary(value)) {
2293         return kIgnoreError_SkPdfResult;
2294     }
2295     SkPdfGraphicsStateDictionary* gs = (SkPdfGraphicsStateDictionary*)value;
2296
2297     if (gs == NULL) {
2298         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL,
2299                                   gs, SkPdfNativeObject::kDictionary_PdfObjectType, pdfContext);
2300         return kIgnoreError_SkPdfResult;
2301     }
2302
2303     if (gs->has_LW()) {
2304         skpdfGraphicsStateApplyLW(pdfContext, gs->LW(pdfContext->fPdfDoc));
2305     }
2306
2307     if (gs->has_LC()) {
2308         skpdfGraphicsStateApplyLC(pdfContext, gs->LC(pdfContext->fPdfDoc));
2309     }
2310
2311     if (gs->has_LJ()) {
2312         skpdfGraphicsStateApplyLJ(pdfContext, gs->LJ(pdfContext->fPdfDoc));
2313     }
2314
2315     if (gs->has_ML()) {
2316         skpdfGraphicsStateApplyML(pdfContext, gs->ML(pdfContext->fPdfDoc));
2317     }
2318
2319     if (gs->has_D()) {
2320         skpdfGraphicsStateApplyD(pdfContext, gs->D(pdfContext->fPdfDoc));
2321     }
2322
2323     if (gs->has_Font()) {
2324         skpdfGraphicsStateApplyFont(pdfContext, gs->Font(pdfContext->fPdfDoc));
2325     }
2326
2327     if (gs->has_BM()) {
2328         if (gs->isBMAName(pdfContext->fPdfDoc)) {
2329             skpdfGraphicsStateApplyBM_name(pdfContext, gs->getBMAsName(pdfContext->fPdfDoc));
2330         } else if (gs->isBMAArray(pdfContext->fPdfDoc)) {
2331             skpdfGraphicsStateApplyBM_array(pdfContext, gs->getBMAsArray(pdfContext->fPdfDoc));
2332         } else {
2333             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, "wrong type", gs->get("BM"),
2334                                       SkPdfNativeObject::kArray_PdfObjectType |
2335                                               SkPdfNativeObject::kName_PdfObjectType, pdfContext);
2336         }
2337     }
2338
2339     if (gs->has_SMask()) {
2340         if (gs->isSMaskAName(pdfContext->fPdfDoc)) {
2341             skpdfGraphicsStateApplySMask_name(pdfContext, gs->getSMaskAsName(pdfContext->fPdfDoc));
2342         } else if (gs->isSMaskADictionary(pdfContext->fPdfDoc)) {
2343             skpdfGraphicsStateApplySMask_dict(pdfContext,
2344                                               gs->getSMaskAsDictionary(pdfContext->fPdfDoc));
2345         } else {
2346             SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity,
2347                                       "wrong type",
2348                                       gs->get("BM"),
2349                                       SkPdfNativeObject::kDictionary_PdfObjectType |
2350                                               SkPdfNativeObject::kName_PdfObjectType,
2351                                               pdfContext);
2352         }
2353     }
2354
2355     if (gs->has_ca()) {
2356         skpdfGraphicsStateApply_ca(pdfContext, gs->ca(pdfContext->fPdfDoc));
2357     }
2358
2359     if (gs->has_CA()) {
2360         skpdfGraphicsStateApply_CA(pdfContext, gs->CA(pdfContext->fPdfDoc));
2361     }
2362
2363     if (gs->has_AIS()) {
2364         skpdfGraphicsStateApplyAIS(pdfContext, gs->AIS(pdfContext->fPdfDoc));
2365     }
2366
2367     // TODO(edisonn): make sure we loaded all those properties in graphic state.
2368
2369     return kOK_SkPdfResult;
2370 }
2371
2372 //charSpace Tc Set the character spacing, Tc
2373 //, to charSpace, which is a number expressed in unscaled text space units.
2374 //  Character spacing is used by the Tj, TJ, and ' operators.
2375 //Initial value: 0.
2376 SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2377     EXPECT_OPERANDS("Tc", pdfContext, 1);
2378     POP_NUMBER(pdfContext, charSpace);
2379     CHECK_PARAMETERS();
2380
2381     pdfContext->fGraphicsState.fCharSpace = charSpace;
2382
2383     return kOK_SkPdfResult;
2384 }
2385
2386 //wordSpace Tw Set the word spacing, T
2387 //w
2388 //, to wordSpace, which is a number expressed in unscaled
2389 //text space units. Word spacing is used by the Tj, TJ, and ' operators. Initial
2390 //value: 0.
2391 SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2392     EXPECT_OPERANDS("Tw", pdfContext, 1);
2393     POP_NUMBER(pdfContext, wordSpace);
2394     CHECK_PARAMETERS();
2395
2396     pdfContext->fGraphicsState.fWordSpace = wordSpace;
2397
2398     return kOK_SkPdfResult;
2399 }
2400
2401 //scale Tz Set the horizontal scaling, Th
2402 //, to (scale ˜ 100). scale is a number specifying the
2403 //percentage of the normal width. Initial value: 100 (normal width).
2404 static SkPdfResult PdfOp_Tz(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2405     EXPECT_OPERANDS("Tz", pdfContext, 1);
2406     POP_NUMBER(pdfContext, scale);
2407     CHECK_PARAMETERS();
2408
2409     if (scale < 0) {
2410         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
2411                     "scale must a positive real number", scale_obj, pdfContext);
2412         return kError_SkPdfResult;
2413     }
2414
2415     return kNYI_SkPdfResult;
2416 }
2417
2418 //render Tr Set the text rendering mode, T
2419 //mode, to render, which is an integer. Initial value: 0.
2420 static SkPdfResult PdfOp_Tr(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2421     EXPECT_OPERANDS("Tr", pdfContext, 1);
2422     POP_INTEGER(pdfContext, mode);
2423     CHECK_PARAMETERS();
2424
2425     if (mode < 0) {  // TODO(edisonn): function/enums with supported modes
2426         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
2427                     "mode must a positive integer or 0", mode_obj, pdfContext);
2428         return kError_SkPdfResult;
2429     }
2430
2431     return kNYI_SkPdfResult;
2432 }
2433 //rise Ts Set the text rise, Trise, to rise, which is a number expressed in unscaled text space
2434 //units. Initial value: 0.
2435 static SkPdfResult PdfOp_Ts(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2436     EXPECT_OPERANDS("Ts", pdfContext, 1);
2437     POP_NUMBER(pdfContext, rise);
2438     CHECK_PARAMETERS();
2439
2440     if (rise < 0) {
2441         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
2442                     "rise must a positive real number", rise_obj, pdfContext);
2443         return kNYI_SkPdfResult;
2444     }
2445
2446     return kNYI_SkPdfResult;
2447 }
2448
2449 //wx wy d0
2450 static SkPdfResult PdfOp_d0(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2451     EXPECT_OPERANDS("d0", pdfContext, 2);
2452     POP_NUMBER(pdfContext, wy);
2453     POP_NUMBER(pdfContext, wx);
2454     CHECK_PARAMETERS();
2455
2456     if (wx < 0) {
2457         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
2458                     "wx must a positive real number", wx_obj, pdfContext);
2459         return kError_SkPdfResult;
2460     }
2461
2462     if (wy < 0) {
2463         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue,
2464                     "wy must a positive real number", wy_obj, pdfContext);
2465         return kError_SkPdfResult;
2466     }
2467
2468     return kNYI_SkPdfResult;
2469 }
2470
2471 //wx wy llx lly urx ury d1
2472 static SkPdfResult PdfOp_d1(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2473     EXPECT_OPERANDS("d1", pdfContext, 6);
2474     POP_NUMBER(pdfContext, ury);
2475     POP_NUMBER(pdfContext, urx);
2476     POP_NUMBER(pdfContext, lly);
2477     POP_NUMBER(pdfContext, llx);
2478     POP_NUMBER(pdfContext, wy);
2479     POP_NUMBER(pdfContext, wx);
2480     CHECK_PARAMETERS();
2481
2482     // TODO(edisonn): really silly quick way to remove warning
2483     if (wx + wy + llx + lly + urx + ury) {
2484         return kNYI_SkPdfResult;
2485     }
2486
2487     return kNYI_SkPdfResult;
2488 }
2489
2490 //name sh
2491 static SkPdfResult PdfOp_sh(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2492     EXPECT_OPERANDS("sh", pdfContext, 1);
2493     POP_NAME(pdfContext, name);
2494     CHECK_PARAMETERS();
2495
2496     if (name == NULL) {
2497         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, name,
2498                                   SkPdfNativeObject::kName_PdfObjectType, pdfContext);
2499         return kError_SkPdfResult;
2500     }
2501
2502     return kNYI_SkPdfResult;
2503 }
2504
2505 //name Do
2506 static SkPdfResult PdfOp_Do(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2507     EXPECT_OPERANDS("Do", pdfContext, 1);
2508     POP_NAME(pdfContext, name);
2509     CHECK_PARAMETERS();
2510
2511     SkPdfDictionary* xObject =  pdfContext->fGraphicsState.fResources->XObject(pdfContext->fPdfDoc);
2512
2513     if (xObject == NULL) {
2514         SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingXObject_SkPdfIssue, NULL,
2515                     pdfContext->fGraphicsState.fResources, pdfContext);
2516         return kIgnoreError_SkPdfResult;
2517     }
2518
2519     SkPdfNativeObject* value = xObject->get(name);
2520     value = pdfContext->fPdfDoc->resolveReference(value);
2521
2522     return doXObject(pdfContext, canvas, value);
2523 }
2524
2525 //tag MP Designate a marked-content point. tag is a name object indicating the role or
2526 //signiﬁcance of the point.
2527 static SkPdfResult PdfOp_MP(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2528     EXPECT_OPERANDS("MP", pdfContext, 1);
2529     POP_OBJ(pdfContext, tag);
2530     CHECK_PARAMETERS();
2531
2532     if (tag == NULL) {
2533         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag,
2534                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
2535         return kNYI_SkPdfResult;
2536     }
2537
2538     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "MP NYI", NULL, NULL);
2539     return kNYI_SkPdfResult;
2540 }
2541
2542 //tag properties DP Designate a marked-content point with an associated property list. tag is a
2543 //name object indicating the role or signiﬁcance of the point; properties is
2544 //either an inline dictionary containing the property list or a name object
2545 //associated with it in the Properties subdictionary of the current resource
2546 //dictionary (see Section 9.5.1, “Property Lists”).
2547 static SkPdfResult PdfOp_DP(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2548     EXPECT_OPERANDS("DP", pdfContext, 2);
2549     POP_OBJ(pdfContext, properties);
2550     POP_OBJ(pdfContext, tag);
2551     CHECK_PARAMETERS();
2552
2553     if (tag == NULL) {
2554         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag,
2555                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
2556         return kNYI_SkPdfResult;
2557     }
2558
2559     if (properties == NULL) {
2560         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, properties,
2561                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
2562         return kNYI_SkPdfResult;
2563     }
2564
2565     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "DP NYI", NULL, NULL);
2566     return kNYI_SkPdfResult;
2567 }
2568
2569 //tag BMC Begin a marked-content sequence terminated by a balancing EMC operator.
2570 //tag is a name object indicating the role or signiﬁcance of the sequence.
2571 static SkPdfResult PdfOp_BMC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2572     EXPECT_OPERANDS("BMC", pdfContext, 1);
2573     POP_OBJ(pdfContext, tag);
2574     CHECK_PARAMETERS();
2575
2576     if (tag == NULL) {
2577         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag,
2578                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
2579         return kNYI_SkPdfResult;
2580     }
2581
2582     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "BMC NYI", NULL, NULL);
2583     return kNYI_SkPdfResult;
2584 }
2585
2586 //tag properties BDC Begin a marked-content sequence with an associated property list, terminated
2587 //by a balancing EMCoperator. tag is a name object indicating the role or significance of the
2588 // sequence; propertiesis either an inline dictionary containing the
2589 //property list or a name object associated with it in the Properties subdictionary of the current
2590 //resource dictionary (see Section 9.5.1, “Property Lists”).
2591 static SkPdfResult PdfOp_BDC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2592     EXPECT_OPERANDS("BDC", pdfContext, 2);
2593     POP_OBJ(pdfContext, properties);
2594     POP_OBJ(pdfContext, tag);
2595     CHECK_PARAMETERS();
2596
2597     if (tag == NULL) {
2598         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag,
2599                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
2600         return kNYI_SkPdfResult;
2601     }
2602
2603     if (properties == NULL) {
2604         SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, properties,
2605                                   SkPdfNativeObject::_kObject_PdfObjectType, pdfContext);
2606         return kNYI_SkPdfResult;
2607     }
2608
2609     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "BDC NYI", NULL, NULL);
2610     return kNYI_SkPdfResult;
2611 }
2612
2613 //— EMC End a marked-content sequence begun by a BMC or BDC operator.
2614 static SkPdfResult PdfOp_EMC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper*) {
2615     SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "EMC NYI", NULL, NULL);
2616     return kNYI_SkPdfResult;
2617 }
2618
2619 #include "SkPdfOps.h"
2620
2621 SkTDict<PdfOperatorRenderer> gPdfOps(100);
2622
2623 static void initPdfOperatorRenderes() {
2624     static bool gInitialized = false;
2625     if (gInitialized) {
2626         return;
2627     }
2628
2629     gPdfOps.set("q", PdfOp_q);
2630     gPdfOps.set("Q", PdfOp_Q);
2631     gPdfOps.set("cm", PdfOp_cm);
2632
2633     gPdfOps.set("TD", PdfOp_TD);
2634     gPdfOps.set("Td", PdfOp_Td);
2635     gPdfOps.set("Tm", PdfOp_Tm);
2636     gPdfOps.set("T*", PdfOp_T_star);
2637
2638     gPdfOps.set("m", PdfOp_m);
2639     gPdfOps.set("l", PdfOp_l);
2640     gPdfOps.set("c", PdfOp_c);
2641     gPdfOps.set("v", PdfOp_v);
2642     gPdfOps.set("y", PdfOp_y);
2643     gPdfOps.set("h", PdfOp_h);
2644     gPdfOps.set("re", PdfOp_re);
2645
2646     gPdfOps.set("S", PdfOp_S);
2647     gPdfOps.set("s", PdfOp_s);
2648     gPdfOps.set("f", PdfOp_f);
2649     gPdfOps.set("F", PdfOp_F);
2650     gPdfOps.set("f*", PdfOp_f_star);
2651     gPdfOps.set("B", PdfOp_B);
2652     gPdfOps.set("B*", PdfOp_B_star);
2653     gPdfOps.set("b", PdfOp_b);
2654     gPdfOps.set("b*", PdfOp_b_star);
2655     gPdfOps.set("n", PdfOp_n);
2656
2657     gPdfOps.set("BT", PdfOp_BT);
2658     gPdfOps.set("ET", PdfOp_ET);
2659
2660     gPdfOps.set("Tj", PdfOp_Tj);
2661     gPdfOps.set("'", PdfOp_quote);
2662     gPdfOps.set("\"", PdfOp_doublequote);
2663     gPdfOps.set("TJ", PdfOp_TJ);
2664
2665     gPdfOps.set("CS", PdfOp_CS);
2666     gPdfOps.set("cs", PdfOp_cs);
2667     gPdfOps.set("SC", PdfOp_SC);
2668     gPdfOps.set("SCN", PdfOp_SCN);
2669     gPdfOps.set("sc", PdfOp_sc);
2670     gPdfOps.set("scn", PdfOp_scn);
2671     gPdfOps.set("G", PdfOp_G);
2672     gPdfOps.set("g", PdfOp_g);
2673     gPdfOps.set("RG", PdfOp_RG);
2674     gPdfOps.set("rg", PdfOp_rg);
2675     gPdfOps.set("K", PdfOp_K);
2676     gPdfOps.set("k", PdfOp_k);
2677
2678     gPdfOps.set("W", PdfOp_W);
2679     gPdfOps.set("W*", PdfOp_W_star);
2680
2681     gPdfOps.set("BX", PdfOp_BX);
2682     gPdfOps.set("EX", PdfOp_EX);
2683
2684     gPdfOps.set("BI", PdfOp_BI);
2685     gPdfOps.set("ID", PdfOp_ID);
2686     gPdfOps.set("EI", PdfOp_EI);
2687
2688     gPdfOps.set("w", PdfOp_w);
2689     gPdfOps.set("J", PdfOp_J);
2690     gPdfOps.set("j", PdfOp_j);
2691     gPdfOps.set("M", PdfOp_M);
2692     gPdfOps.set("d", PdfOp_d);
2693     gPdfOps.set("ri", PdfOp_ri);
2694     gPdfOps.set("i", PdfOp_i);
2695     gPdfOps.set("gs", PdfOp_gs);
2696
2697     gPdfOps.set("Tc", PdfOp_Tc);
2698     gPdfOps.set("Tw", PdfOp_Tw);
2699     gPdfOps.set("Tz", PdfOp_Tz);
2700     gPdfOps.set("TL", PdfOp_TL);
2701     gPdfOps.set("Tf", PdfOp_Tf);
2702     gPdfOps.set("Tr", PdfOp_Tr);
2703     gPdfOps.set("Ts", PdfOp_Ts);
2704
2705     gPdfOps.set("d0", PdfOp_d0);
2706     gPdfOps.set("d1", PdfOp_d1);
2707
2708     gPdfOps.set("sh", PdfOp_sh);
2709
2710     gPdfOps.set("Do", PdfOp_Do);
2711
2712     gPdfOps.set("MP", PdfOp_MP);
2713     gPdfOps.set("DP", PdfOp_DP);
2714     gPdfOps.set("BMC", PdfOp_BMC);
2715     gPdfOps.set("BDC", PdfOp_BDC);
2716     gPdfOps.set("EMC", PdfOp_EMC);
2717
2718     gInitialized = true;
2719 }
2720
2721 class InitPdfOps {
2722 public:
2723     InitPdfOps() {
2724         initPdfOperatorRenderes();
2725     }
2726 };
2727
2728 InitPdfOps gInitPdfOps;
2729
2730 SkPdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) {
2731     SkASSERT(false);
2732     return kIgnoreError_SkPdfResult;
2733 }
2734
2735 void PdfInlineImageLooper::loop() {
2736     // FIXME (scroggo): Does this need to be looper? It does not consumeTokens,
2737     // nor does it loop. The one thing it does is provide access to the
2738     // protected members of SkPdfTokenLooper.
2739     doXObject_Image(fPdfContext, fCanvas, fTokenizer->readInlineImage());
2740 }
2741
2742 SkPdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) {
2743     return fParent->consumeToken(token);
2744 }
2745
2746 void PdfCompatibilitySectionLooper::loop() {
2747     PdfOp_q(fPdfContext, fCanvas, NULL);
2748
2749     PdfToken token;
2750     while (fTokenizer->readToken(&token)) {
2751         if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) {
2752             PdfCompatibilitySectionLooper looper(this);
2753             looper.loop();
2754         } else {
2755             if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX") == 0) {
2756                 break;
2757             }
2758             fParent->consumeToken(token);
2759         }
2760     }
2761
2762     PdfOp_Q(fPdfContext, fCanvas, NULL);
2763 }
2764
2765 // TODO(edisonn): for debugging - remove or put it in a #ifdef
2766 SkPdfContext* gPdfContext = NULL;
2767
2768 bool SkPdfRenderer::renderPage(int page, SkCanvas* canvas, const SkRect& dst) const {
2769     if (!fPdfDoc) {
2770         return false;
2771     }
2772
2773     if (page < 0 || page >= pages()) {
2774         return false;
2775     }
2776
2777     SkPdfContext pdfContext(fPdfDoc);
2778
2779     // FIXME (scroggo): Is this matrix needed?
2780     pdfContext.fOriginalMatrix = SkMatrix::I();
2781     pdfContext.fGraphicsState.fResources = fPdfDoc->pageResources(page);
2782
2783     gPdfContext = &pdfContext;
2784
2785     SkScalar z = SkIntToScalar(0);
2786     SkScalar w = dst.width();
2787     SkScalar h = dst.height();
2788
2789     if (SkScalarTruncToInt(w) <= 0 || SkScalarTruncToInt(h) <= 0) {
2790         return true;
2791     }
2792
2793     // FIXME (scroggo): The media box may not be anchored at 0,0. Is this okay?
2794     SkScalar wp = fPdfDoc->MediaBox(page).width();
2795     SkScalar hp = fPdfDoc->MediaBox(page).height();
2796
2797     SkPoint pdfSpace[4] = {SkPoint::Make(z, z),
2798                            SkPoint::Make(wp, z),
2799                            SkPoint::Make(wp, hp),
2800                            SkPoint::Make(z, hp)};
2801
2802 #ifdef PDF_DEBUG_3X
2803     // Use larger image to make sure we do not draw anything outside of page
2804     // could be used in tests.
2805     SkPoint skiaSpace[4] = {SkPoint::Make(w+z, h+h),
2806                             SkPoint::Make(w+w, h+h),
2807                             SkPoint::Make(w+w, h+z),
2808                             SkPoint::Make(w+z, h+z)};
2809 #else
2810     SkPoint skiaSpace[4] = {SkPoint::Make(z, h),
2811                             SkPoint::Make(w, h),
2812                             SkPoint::Make(w, z),
2813                             SkPoint::Make(z, z)};
2814 #endif
2815
2816     SkAssertResult(pdfContext.fOriginalMatrix.setPolyToPoly(pdfSpace, skiaSpace, 4));
2817     SkTraceMatrix(pdfContext.fOriginalMatrix, "Original matrix");
2818
2819     // FIXME (scroggo): Do we need to translate to account for the fact that
2820     // the media box (or the destination rect) may not be anchored at 0,0?
2821     pdfContext.fOriginalMatrix.postConcat(canvas->getTotalMatrix());
2822
2823     pdfContext.fGraphicsState.fCTM = pdfContext.fOriginalMatrix;
2824     pdfContext.fGraphicsState.fContentStreamMatrix = pdfContext.fOriginalMatrix;
2825     pdfContext.fGraphicsState.fMatrixTm = pdfContext.fGraphicsState.fCTM;
2826     pdfContext.fGraphicsState.fMatrixTlm = pdfContext.fGraphicsState.fCTM;
2827
2828 #ifndef PDF_DEBUG_NO_PAGE_CLIPING
2829     canvas->clipRect(dst, SkRegion::kIntersect_Op, true);
2830 #endif
2831
2832     // FIXME (scroggo): This concat may not be necessary, since we generally
2833     // call SkCanvas::setMatrix() before using the canvas.
2834     canvas->concat(pdfContext.fOriginalMatrix);
2835
2836     doPage(&pdfContext, canvas, fPdfDoc->page(page));
2837
2838           // TODO(edisonn:) erase with white before draw? Right now the caller is responsible.
2839 //        SkPaint paint;
2840 //        paint.setColor(SK_ColorWHITE);
2841 //        canvas->drawRect(rect, paint);
2842
2843
2844     canvas->flush();
2845     return true;
2846 }
2847
2848 SkPdfRenderer* SkPdfRenderer::CreateFromFile(const char* inputFileName) {
2849     // FIXME: SkPdfNativeDoc should have a similar Create function.
2850     SkPdfNativeDoc* pdfDoc = SkNEW_ARGS(SkPdfNativeDoc, (inputFileName));
2851     if (pdfDoc->pages() == 0) {
2852         SkDELETE(pdfDoc);
2853         return NULL;
2854     }
2855
2856     return SkNEW_ARGS(SkPdfRenderer, (pdfDoc));
2857 }
2858
2859 SkPdfRenderer* SkPdfRenderer::CreateFromStream(SkStream* stream) {
2860     // TODO(edisonn): create static function that could return NULL if there are errors
2861     SkPdfNativeDoc* pdfDoc = SkNEW_ARGS(SkPdfNativeDoc, (stream));
2862     if (pdfDoc->pages() == 0) {
2863         SkDELETE(pdfDoc);
2864         return NULL;
2865     }
2866
2867     return SkNEW_ARGS(SkPdfRenderer, (pdfDoc));
2868 }
2869
2870 SkPdfRenderer::SkPdfRenderer(SkPdfNativeDoc* doc)
2871     :fPdfDoc(doc) {
2872 }
2873
2874 SkPdfRenderer::~SkPdfRenderer() {
2875     SkDELETE(fPdfDoc);
2876 }
2877
2878 int SkPdfRenderer::pages() const {
2879     SkASSERT(fPdfDoc != NULL);
2880     return fPdfDoc->pages();
2881 }
2882
2883 SkRect SkPdfRenderer::MediaBox(int page) const {
2884     SkASSERT(fPdfDoc != NULL);
2885     return fPdfDoc->MediaBox(page);
2886 }
2887
2888 size_t SkPdfRenderer::bytesUsed() const {
2889     SkASSERT(fPdfDoc != NULL);
2890     return fPdfDoc->bytesUsed();
2891 }
2892
2893 bool SkPDFNativeRenderToBitmap(SkStream* stream,
2894                                SkBitmap* output,
2895                                int page,
2896                                SkPdfContent unused,
2897                                double dpi) {
2898     SkASSERT(page >= 0);
2899     SkPdfRenderer* renderer = SkPdfRenderer::CreateFromStream(stream);
2900     if (NULL == renderer) {
2901         return false;
2902     }
2903
2904     SkRect rect = renderer->MediaBox(page < 0 ? 0 :page);
2905
2906     SkScalar width = SkScalarMul(rect.width(),  SkDoubleToScalar(dpi / 72.0));
2907     SkScalar height = SkScalarMul(rect.height(),  SkDoubleToScalar(dpi / 72.0));
2908
2909     rect = SkRect::MakeWH(width, height);
2910
2911     setup_bitmap(output, SkScalarCeilToInt(width), SkScalarCeilToInt(height));
2912
2913     SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (*output)));
2914     SkCanvas canvas(device);
2915
2916     return renderer->renderPage(page, &canvas, rect);
2917 }