| /* |
| * Copyright 2013 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkPdfConfig.h" |
| #include "SkPdfDiffEncoder.h" |
| #include "SkPdfNativeObject.h" |
| #include "SkPdfNativeTokenizer.h" |
| #include "SkPdfUtils.h" |
| |
| // TODO(edisonn): mac builder does not find the header ... but from headers is ok |
| //#include "SkPdfStreamCommonDictionary_autogen.h" |
| //#include "SkPdfImageDictionary_autogen.h" |
| #include "SkPdfHeaders_autogen.h" |
| |
| |
| // TODO(edisonn): Perf, Make this function run faster. |
| // There could be 0s between start and end. |
| // needle will not contain 0s. |
| static char* strrstrk(char* hayStart, char* hayEnd, const char* needle) { |
| int needleLen = strlen(needle); |
| if ((isPdfWhiteSpaceOrPdfDelimiter(*(hayStart+needleLen)) || (hayStart+needleLen == hayEnd)) && |
| strncmp(hayStart, needle, needleLen) == 0) { |
| return hayStart; |
| } |
| |
| hayStart++; |
| |
| while (hayStart < hayEnd) { |
| if (isPdfWhiteSpaceOrPdfDelimiter(*(hayStart-1)) && |
| (isPdfWhiteSpaceOrPdfDelimiter(*(hayStart+needleLen)) || |
| (hayStart+needleLen == hayEnd)) && |
| strncmp(hayStart, needle, needleLen) == 0) { |
| return hayStart; |
| } |
| hayStart++; |
| } |
| return NULL; |
| } |
| |
| const unsigned char* skipPdfWhiteSpaces(const unsigned char* start, const unsigned char* end) { |
| while (start < end && (isPdfWhiteSpace(*start) || *start == kComment_PdfDelimiter)) { |
| TRACE_COMMENT(*start); |
| if (*start == kComment_PdfDelimiter) { |
| // skip the comment until end of line |
| while (start < end && !isPdfEOL(*start)) { |
| start++; |
| TRACE_COMMENT(*start); |
| } |
| } else { |
| start++; |
| } |
| } |
| return start; |
| } |
| |
| const unsigned char* endOfPdfToken(const unsigned char* start, const unsigned char* end) { |
| SkASSERT(!isPdfWhiteSpace(*start)); |
| |
| if (start < end && isPdfDelimiter(*start)) { |
| TRACE_TK(*start); |
| start++; |
| return start; |
| } |
| |
| while (start < end && !isPdfWhiteSpaceOrPdfDelimiter(*start)) { |
| TRACE_TK(*start); |
| start++; |
| } |
| return start; |
| } |
| |
| // The parsing should end with a ]. |
| static const unsigned char* readArray(const unsigned char* start, const unsigned char* end, |
| SkPdfNativeObject* array, |
| SkPdfAllocator* allocator, SkPdfNativeDoc* doc) { |
| SkPdfNativeObject::makeEmptyArray(array); |
| // PUT_TRACK_STREAM(array, start, start) |
| |
| if (allocator == NULL) { |
| // TODO(edisonn): report/warning error/assert |
| return end; |
| } |
| |
| while (start < end) { |
| // skip white spaces |
| start = skipPdfWhiteSpaces(start, end); |
| |
| const unsigned char* endOfToken = endOfPdfToken(start, end); |
| |
| if (endOfToken == start) { |
| // TODO(edisonn): report error in pdf file (end of stream with ] for end of aray |
| return start; |
| } |
| |
| if (endOfToken == start + 1 && *start == kClosedSquareBracket_PdfDelimiter) { |
| return endOfToken; |
| } |
| |
| SkPdfNativeObject* newObj = allocator->allocObject(); |
| start = nextObject(start, end, newObj, allocator, doc); |
| // TODO(edisonn): perf/memory: put the variables on the stack, and flush them on the array |
| // only when we are sure they are not references! |
| if (newObj->isKeywordReference() && array->size() >= 2 && |
| array->objAtAIndex(array->size() - 1)->isInteger() && |
| array->objAtAIndex(array->size() - 2)->isInteger()) { |
| SkPdfNativeObject* gen = array->removeLastInArray(); |
| SkPdfNativeObject* id = array->removeLastInArray(); |
| |
| SkPdfNativeObject::resetAndMakeReference((unsigned int)id->intValue(), |
| (unsigned int)gen->intValue(), newObj); |
| // newObj PUT_TRACK_PARAMETERS_OBJ2(id, newObj) - store end, as now |
| } |
| array->appendInArray(newObj); |
| } |
| // TODO(edisonn): report not reached, we should never get here |
| // TODO(edisonn): there might be a bug here, enable an assert and run it on files |
| // or it might be that the files were actually corrupted |
| return start; |
| } |
| |
| static const unsigned char* readString(const unsigned char* start, const unsigned char* end, |
| unsigned char* out) { |
| const unsigned char* in = start; |
| bool hasOut = (out != NULL); |
| |
| int openRoundBrackets = 1; |
| while (in < end) { |
| openRoundBrackets += ((*in) == kOpenedRoundBracket_PdfDelimiter); |
| openRoundBrackets -= ((*in) == kClosedRoundBracket_PdfDelimiter); |
| if (openRoundBrackets == 0) { |
| in++; // consumed ) |
| break; |
| } |
| |
| if (*in == kEscape_PdfSpecial) { |
| if (in + 1 < end) { |
| switch (in[1]) { |
| case 'n': |
| if (hasOut) { *out = kLF_PdfWhiteSpace; } |
| out++; |
| in += 2; |
| break; |
| |
| case 'r': |
| if (hasOut) { *out = kCR_PdfWhiteSpace; } |
| out++; |
| in += 2; |
| break; |
| |
| case 't': |
| if (hasOut) { *out = kHT_PdfWhiteSpace; } |
| out++; |
| in += 2; |
| break; |
| |
| case 'b': |
| // TODO(edisonn): any special meaning to backspace? |
| if (hasOut) { *out = kBackspace_PdfSpecial; } |
| out++; |
| in += 2; |
| break; |
| |
| case 'f': |
| if (hasOut) { *out = kFF_PdfWhiteSpace; } |
| out++; |
| in += 2; |
| break; |
| |
| case kOpenedRoundBracket_PdfDelimiter: |
| if (hasOut) { *out = kOpenedRoundBracket_PdfDelimiter; } |
| out++; |
| in += 2; |
| break; |
| |
| case kClosedRoundBracket_PdfDelimiter: |
| if (hasOut) { *out = kClosedRoundBracket_PdfDelimiter; } |
| out++; |
| in += 2; |
| break; |
| |
| case kEscape_PdfSpecial: |
| if (hasOut) { *out = kEscape_PdfSpecial; } |
| out++; |
| in += 2; |
| break; |
| |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': { |
| //read octals |
| in++; // consume backslash |
| |
| int code = 0; |
| int i = 0; |
| while (in < end && *in >= '0' && *in < '8') { |
| code = (code << 3) + ((*in) - '0'); // code * 8 + d |
| i++; |
| in++; |
| if (i == 3) { |
| if (hasOut) { *out = code & 0xff; } |
| out++; |
| i = 0; |
| } |
| } |
| if (i > 0) { |
| if (hasOut) { *out = code & 0xff; } |
| out++; |
| } |
| } |
| break; |
| |
| default: |
| // Per spec, backslash is ignored if escaped ch is unknown |
| in++; |
| break; |
| } |
| } else { |
| in++; |
| } |
| } else { |
| if (hasOut) { *out = *in; } |
| in++; |
| out++; |
| } |
| } |
| |
| if (hasOut) { |
| return in; // consumed already ) at the end of the string |
| } else { |
| // return where the string would end if we reuse the string |
| return start + (out - (const unsigned char*)NULL); |
| } |
| } |
| |
| static int readStringLength(const unsigned char* start, const unsigned char* end) { |
| return readString(start, end, NULL) - start; |
| } |
| |
| static const unsigned char* readString(const unsigned char* start, const unsigned char* end, |
| SkPdfNativeObject* str, SkPdfAllocator* allocator) { |
| if (!allocator) { |
| // TODO(edisonn): report error/warn/assert |
| return end; |
| } |
| |
| int outLength = readStringLength(start, end); |
| unsigned char* out = (unsigned char*)allocator->alloc(outLength); |
| const unsigned char* now = readString(start, end, out); |
| SkPdfNativeObject::makeString(out, out + outLength, str); |
| // PUT_TRACK_STREAM(str, start, now) |
| TRACE_STRING(out, out + outLength); |
| return now; // consumed already ) at the end of the string |
| } |
| |
| static const unsigned char* readHexString(const unsigned char* start, const unsigned char* end, |
| unsigned char* out) { |
| bool hasOut = (out != NULL); |
| const unsigned char* in = start; |
| |
| unsigned char code = 0; |
| |
| while (in < end) { |
| while (in < end && isPdfWhiteSpace(*in)) { |
| in++; |
| } |
| |
| if (*in == kClosedInequityBracket_PdfDelimiter) { |
| in++; // consume > |
| // normal exit |
| break; |
| } |
| |
| if (in >= end) { |
| // end too soon |
| break; |
| } |
| |
| switch (*in) { |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| code = (*in - '0') << 4; |
| break; |
| |
| case 'a': |
| case 'b': |
| case 'c': |
| case 'd': |
| case 'e': |
| case 'f': |
| code = (*in - 'a' + 10) << 4; |
| break; |
| |
| case 'A': |
| case 'B': |
| case 'C': |
| case 'D': |
| case 'E': |
| case 'F': |
| code = (*in - 'A' + 10) << 4; |
| break; |
| |
| // TODO(edisonn): spec does not say how to handle this error |
| default: |
| break; |
| } |
| |
| in++; // advance |
| |
| while (in < end && isPdfWhiteSpace(*in)) { |
| in++; |
| } |
| |
| // TODO(edisonn): report error |
| if (in >= end) { |
| if (hasOut) { *out = code; } |
| out++; |
| break; |
| } |
| |
| if (*in == kClosedInequityBracket_PdfDelimiter) { |
| if (hasOut) { *out = code; } |
| out++; |
| in++; |
| break; |
| } |
| |
| switch (*in) { |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| code += (*in - '0'); |
| break; |
| |
| case 'a': |
| case 'b': |
| case 'c': |
| case 'd': |
| case 'e': |
| case 'f': |
| code += (*in - 'a' + 10); |
| break; |
| |
| case 'A': |
| case 'B': |
| case 'C': |
| case 'D': |
| case 'E': |
| case 'F': |
| code += (*in - 'A' + 10); |
| break; |
| |
| // TODO(edisonn): spec does not say how to handle this error |
| default: |
| break; |
| } |
| |
| if (hasOut) { *out = code; } |
| out++; |
| in++; |
| } |
| |
| if (hasOut) { |
| return in; // consumed already ) at the end of the string |
| } else { |
| // return where the string would end if we reuse the string |
| return start + (out - (const unsigned char*)NULL); |
| } |
| } |
| |
| static int readHexStringLength(const unsigned char* start, const unsigned char* end) { |
| return readHexString(start, end, NULL) - start; |
| } |
| |
| static const unsigned char* readHexString(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* str, SkPdfAllocator* allocator) { |
| if (!allocator) { |
| // TODO(edisonn): report error/warn/assert |
| return end; |
| } |
| int outLength = readHexStringLength(start, end); |
| unsigned char* out = (unsigned char*)allocator->alloc(outLength); |
| const unsigned char* now = readHexString(start, end, out); |
| SkPdfNativeObject::makeHexString(out, out + outLength, str); |
| // str PUT_TRACK_STREAM(start, now) |
| TRACE_HEXSTRING(out, out + outLength); |
| return now; // consumed already > at the end of the string |
| } |
| |
| // TODO(edisonn): add version parameter, before PDF 1.2 name could not have special characters. |
| static const unsigned char* readName(const unsigned char* start, const unsigned char* end, |
| unsigned char* out) { |
| bool hasOut = (out != NULL); |
| const unsigned char* in = start; |
| |
| unsigned char code = 0; |
| |
| while (in < end) { |
| if (isPdfWhiteSpaceOrPdfDelimiter(*in)) { |
| break; |
| } |
| |
| if (*in == '#' && in + 2 < end) { |
| in++; |
| switch (*in) { |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| code = (*in - '0') << 4; |
| break; |
| |
| case 'a': |
| case 'b': |
| case 'c': |
| case 'd': |
| case 'e': |
| case 'f': |
| code = (*in - 'a' + 10) << 4; |
| break; |
| |
| case 'A': |
| case 'B': |
| case 'C': |
| case 'D': |
| case 'E': |
| case 'F': |
| code = (*in - 'A' + 10) << 4; |
| break; |
| |
| // TODO(edisonn): spec does not say how to handle this error |
| default: |
| break; |
| } |
| |
| in++; // advance |
| |
| switch (*in) { |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| code += (*in - '0'); |
| break; |
| |
| case 'a': |
| case 'b': |
| case 'c': |
| case 'd': |
| case 'e': |
| case 'f': |
| code += (*in - 'a' + 10); |
| break; |
| |
| case 'A': |
| case 'B': |
| case 'C': |
| case 'D': |
| case 'E': |
| case 'F': |
| code += (*in - 'A' + 10); |
| break; |
| |
| // TODO(edisonn): spec does not say how to handle this error |
| default: |
| break; |
| } |
| |
| if (hasOut) { *out = code; } |
| out++; |
| in++; |
| } else { |
| if (hasOut) { *out = *in; } |
| out++; |
| in++; |
| } |
| } |
| |
| if (hasOut) { |
| return in; // consumed already ) at the end of the string |
| } else { |
| // return where the string would end if we reuse the string |
| return start + (out - (const unsigned char*)NULL); |
| } |
| } |
| |
| static int readNameLength(const unsigned char* start, const unsigned char* end) { |
| return readName(start, end, NULL) - start; |
| } |
| |
| static const unsigned char* readName(const unsigned char* start, const unsigned char* end, |
| SkPdfNativeObject* name, SkPdfAllocator* allocator) { |
| if (!allocator) { |
| // TODO(edisonn): report error/warn/assert |
| return end; |
| } |
| int outLength = readNameLength(start, end); |
| unsigned char* out = (unsigned char*)allocator->alloc(outLength); |
| const unsigned char* now = readName(start, end, out); |
| SkPdfNativeObject::makeName(out, out + outLength, name); |
| //PUT_TRACK_STREAM(start, now) |
| TRACE_NAME(out, out + outLength); |
| return now; |
| } |
| |
| // TODO(edisonn): pdf spec let Length to be an indirect object define after the stream |
| // that makes for an interesting scenario, where the stream itself contains endstream, together |
| // with a reference object with the length, but the real length object would be somewhere else |
| // it could confuse the parser |
| /*example: |
| |
| 7 0 obj |
| << /length 8 0 R>> |
| stream |
| ............... |
| endstream |
| 8 0 obj #we are in stream actually, not a real object |
| << 10 >> #we are in stream actually, not a real object |
| endobj |
| endstream |
| 8 0 obj #real obj |
| << 100 >> #real obj |
| endobj |
| and it could get worse, with multiple object like this |
| */ |
| |
| // right now implement the silly algorithm that assumes endstream is finishing the stream |
| |
| static const unsigned char* readStream(const unsigned char* start, const unsigned char* end, |
| SkPdfNativeObject* dict, SkPdfNativeDoc* doc) { |
| start = skipPdfWhiteSpaces(start, end); |
| if (!( start[0] == 's' && |
| start[1] == 't' && |
| start[2] == 'r' && |
| start[3] == 'e' && |
| start[4] == 'a' && |
| start[5] == 'm')) { |
| // no stream. return. |
| return start; |
| } |
| |
| start += 6; // strlen("stream") |
| if (start[0] == kCR_PdfWhiteSpace && start[1] == kLF_PdfWhiteSpace) { |
| start += 2; |
| } else if (start[0] == kLF_PdfWhiteSpace) { |
| start += 1; |
| } else if (isPdfWhiteSpace(start[0])) { |
| start += 1; |
| } else { |
| // TODO(edisonn): warn it should be isPdfDelimiter(start[0])) ? |
| } |
| |
| SkPdfStreamCommonDictionary* stream = (SkPdfStreamCommonDictionary*) dict; |
| // TODO(edisonn): load Length |
| int64_t length = -1; |
| |
| // TODO(edisonn): very basic implementation |
| if (stream->has_Length() && stream->Length(doc) > 0) { |
| length = stream->Length(doc); |
| } |
| |
| // TODO(edisonn): load external streams |
| // TODO(edisonn): look at the last filter, to determine how to deal with possible parsing |
| // issues. The last filter can have special rules to terminate a stream, which we could |
| // use to determine end of stream. |
| |
| if (length >= 0) { |
| const unsigned char* endstream = start + length; |
| |
| if (endstream[0] == kCR_PdfWhiteSpace && endstream[1] == kLF_PdfWhiteSpace) { |
| endstream += 2; |
| } else if (endstream[0] == kLF_PdfWhiteSpace) { |
| endstream += 1; |
| } |
| |
| if (strncmp((const char*)endstream, "endstream", strlen("endstream")) != 0) { |
| length = -1; |
| } |
| } |
| |
| if (length < 0) { |
| // scan the buffer, until we find first endstream |
| // TODO(edisonn): all buffers must have a 0 at the end now, |
| const unsigned char* endstream = (const unsigned char*)strrstrk((char*)start, (char*)end, |
| "endstream"); |
| |
| if (endstream) { |
| length = endstream - start; |
| if (*(endstream-1) == kLF_PdfWhiteSpace) length--; |
| if (*(endstream-2) == kCR_PdfWhiteSpace) length--; |
| } |
| } |
| if (length >= 0) { |
| const unsigned char* endstream = start + length; |
| |
| if (endstream[0] == kCR_PdfWhiteSpace && endstream[1] == kLF_PdfWhiteSpace) { |
| endstream += 2; |
| } else if (endstream[0] == kLF_PdfWhiteSpace) { |
| endstream += 1; |
| } |
| |
| // TODO(edisonn): verify the next bytes are "endstream" |
| |
| endstream += strlen("endstream"); |
| // TODO(edisonn): Assert? report error/warning? |
| dict->addStream(start, (size_t)length); |
| return endstream; |
| } |
| return start; |
| } |
| |
| static const unsigned char* readInlineImageStream(const unsigned char* start, |
| const unsigned char* end, |
| SkPdfImageDictionary* inlineImage, |
| SkPdfNativeDoc* doc) { |
| // We already processed ID keyword, and we should be positioned immediately after it |
| |
| // TODO(edisonn): security: either make all streams to have extra 2 bytes at the end, |
| // instead of this if. |
| //if (end - start <= 2) { |
| // // TODO(edisonn): warning? |
| // return end; // but can we have a pixel image encoded in 1-2 bytes? |
| //} |
| |
| if (start[0] == kCR_PdfWhiteSpace && start[1] == kLF_PdfWhiteSpace) { |
| start += 2; |
| } else if (start[0] == kLF_PdfWhiteSpace) { |
| start += 1; |
| } else if (isPdfWhiteSpace(start[0])) { |
| start += 1; |
| } else { |
| SkASSERT(isPdfDelimiter(start[0])); |
| // TODO(edisonn): warning? |
| } |
| |
| const unsigned char* endstream = (const unsigned char*)strrstrk((char*)start, (char*)end, "EI"); |
| const unsigned char* endEI = endstream ? endstream + 2 : NULL; // 2 == strlen("EI") |
| |
| if (endstream) { |
| int length = endstream - start; |
| if (*(endstream-1) == kLF_PdfWhiteSpace) length--; |
| if (*(endstream-2) == kCR_PdfWhiteSpace) length--; |
| inlineImage->addStream(start, (size_t)length); |
| } else { |
| // TODO(edisonn): report error in inline image stream (ID-EI) section |
| // TODO(edisonn): based on filter, try to ignore a missing EI, and read data properly |
| return end; |
| } |
| return endEI; |
| } |
| |
| static const unsigned char* readDictionary(const unsigned char* start, const unsigned char* end, |
| SkPdfNativeObject* dict, |
| SkPdfAllocator* allocator, SkPdfNativeDoc* doc) { |
| if (allocator == NULL) { |
| // TODO(edisonn): report/warning error |
| return end; |
| } |
| SkPdfNativeObject::makeEmptyDictionary(dict); |
| // PUT_TRACK_STREAM(dict, start, start) |
| |
| start = skipPdfWhiteSpaces(start, end); |
| SkPdfAllocator tmpStorage; // keys will be stored in dict, we can free them after set. |
| |
| while (start < end && *start == kNamed_PdfDelimiter) { |
| SkPdfNativeObject key; |
| //*start = '\0'; |
| start++; |
| start = readName(start, end, &key, &tmpStorage); |
| start = skipPdfWhiteSpaces(start, end); |
| |
| if (start < end) { |
| SkPdfNativeObject* value = allocator->allocObject(); |
| start = nextObject(start, end, value, allocator, doc); |
| |
| start = skipPdfWhiteSpaces(start, end); |
| |
| if (start < end) { |
| // We should have an indirect reference |
| if (isPdfDigit(*start)) { |
| SkPdfNativeObject generation; |
| start = nextObject(start, end, &generation, allocator, doc); |
| |
| SkPdfNativeObject keywordR; |
| start = nextObject(start, end, &keywordR, allocator, doc); |
| |
| if (value->isInteger() && generation.isInteger() && |
| keywordR.isKeywordReference()) { |
| int64_t id = value->intValue(); |
| SkPdfNativeObject::resetAndMakeReference( |
| (unsigned int)id, |
| (unsigned int)generation.intValue(), |
| value); |
| // PUT_TRACK_PARAMETERS_OBJ2(value, &generation) |
| dict->set(&key, value); |
| } else { |
| // TODO(edisonn) error?, ignore it for now. |
| dict->set(&key, value); |
| } |
| } else { |
| // next elem is not a digit, but it might not be / either! |
| dict->set(&key, value); |
| } |
| } else { |
| // /key >> |
| dict->set(&key, value); |
| return end; |
| } |
| start = skipPdfWhiteSpaces(start, end); |
| } else { |
| dict->set(&key, &SkPdfNativeObject::kNull); |
| return end; |
| } |
| } |
| |
| // now we should expect >> |
| start = skipPdfWhiteSpaces(start, end); |
| if (*start != kClosedInequityBracket_PdfDelimiter) { |
| // TODO(edisonn): report/warning |
| } |
| |
| start++; // skip > |
| if (*start != kClosedInequityBracket_PdfDelimiter) { |
| // TODO(edisonn): report/warning |
| } |
| |
| start++; // skip > |
| |
| //STORE_TRACK_PARAMETER_OFFSET_END(dict,start); |
| |
| start = readStream(start, end, dict, doc); |
| |
| return start; |
| } |
| |
| const unsigned char* nextObject(const unsigned char* start, const unsigned char* end, |
| SkPdfNativeObject* token, |
| SkPdfAllocator* allocator, SkPdfNativeDoc* doc) { |
| const unsigned char* current; |
| |
| // skip white spaces |
| start = skipPdfWhiteSpaces(start, end); |
| |
| if (start >= end) { |
| return end; |
| } |
| |
| current = endOfPdfToken(start, end); |
| |
| // no token, len would be 0 |
| if (current == start || current == end) { |
| return end; |
| } |
| |
| int tokenLen = current - start; |
| |
| if (tokenLen == 1) { |
| // start array |
| switch (*start) { |
| case kOpenedSquareBracket_PdfDelimiter: |
| return readArray(current, end, token, allocator, doc); |
| |
| case kOpenedRoundBracket_PdfDelimiter: |
| return readString(start + 1, end, token, allocator); |
| |
| case kOpenedInequityBracket_PdfDelimiter: |
| if (end > start + 1 && start[1] == kOpenedInequityBracket_PdfDelimiter) { |
| // TODO(edisonn): pass here the length somehow? |
| return readDictionary(start + 2, end, token, allocator, doc); // skip << |
| } else { |
| return readHexString(start + 1, end, token, allocator); // skip < |
| } |
| |
| case kNamed_PdfDelimiter: |
| return readName(start + 1, end, token, allocator); |
| |
| // TODO(edisonn): what to do curly brackets? |
| case kOpenedCurlyBracket_PdfDelimiter: |
| default: |
| break; |
| } |
| |
| SkASSERT(!isPdfWhiteSpace(*start)); |
| if (isPdfDelimiter(*start)) { |
| // TODO(edisonn): how unexpected stream ] } > ) will be handled? |
| // for now ignore, and it will become a keyword to be ignored |
| } |
| } |
| |
| if (tokenLen == 4 && start[0] == 'n' && start[1] == 'u' && start[2] == 'l' && start[3] == 'l') { |
| SkPdfNativeObject::makeNull(token); |
| // PUT_TRACK_STREAM(start, start + 4) |
| return current; |
| } |
| |
| if (tokenLen == 4 && start[0] == 't' && start[1] == 'r' && start[2] == 'u' && start[3] == 'e') { |
| SkPdfNativeObject::makeBoolean(true, token); |
| // PUT_TRACK_STREAM(start, start + 4) |
| return current; |
| } |
| |
| // TODO(edisonn): again, make all buffers have 5 extra bytes |
| if (tokenLen == 5 && start[0] == 'f' && |
| start[1] == 'a' && |
| start[2] == 'l' && |
| start[3] == 's' && |
| start[4] == 'e') { |
| SkPdfNativeObject::makeBoolean(false, token); |
| // PUT_TRACK_STREAM(start, start + 5) |
| return current; |
| } |
| |
| if (isPdfNumeric(*start)) { |
| SkPdfNativeObject::makeNumeric(start, current, token); |
| // PUT_TRACK_STREAM(start, current) |
| } else { |
| SkPdfNativeObject::makeKeyword(start, current, token); |
| // PUT_TRACK_STREAM(start, current) |
| } |
| return current; |
| } |
| |
| SkPdfNativeObject* SkPdfAllocator::allocBlock() { |
| fSizeInBytes += BUFFER_SIZE * sizeof(SkPdfNativeObject); |
| return new SkPdfNativeObject[BUFFER_SIZE]; |
| } |
| |
| SkPdfAllocator::~SkPdfAllocator() { |
| for (int i = 0 ; i < fHandles.count(); i++) { |
| free(fHandles[i]); |
| } |
| for (int i = 0 ; i < fHistory.count(); i++) { |
| for (int j = 0 ; j < BUFFER_SIZE; j++) { |
| fHistory[i][j].reset(); |
| } |
| delete[] fHistory[i]; |
| } |
| for (int j = 0 ; j < BUFFER_SIZE; j++) { |
| fCurrent[j].reset(); |
| } |
| delete[] fCurrent; |
| } |
| |
| SkPdfNativeObject* SkPdfAllocator::allocObject() { |
| if (fCurrentUsed >= BUFFER_SIZE) { |
| fHistory.push(fCurrent); |
| fCurrent = allocBlock(); |
| fCurrentUsed = 0; |
| fSizeInBytes += sizeof(SkPdfNativeObject*); |
| } |
| fCurrentUsed++; |
| return &fCurrent[fCurrentUsed - 1]; |
| } |
| |
| // TODO(edisonn): perf: do no copy the buffers, but reuse them, and mark cache the result, |
| // so there is no need of a second pass |
| SkPdfNativeTokenizer::SkPdfNativeTokenizer(SkPdfNativeObject* objWithStream, |
| SkPdfAllocator* allocator, |
| SkPdfNativeDoc* doc) |
| : fDoc(doc) |
| , fAllocator(allocator) |
| , fUncompressedStream(NULL) |
| , fUncompressedStreamEnd(NULL) |
| , fEmpty(false) |
| , fHasPutBack(false) { |
| const unsigned char* buffer = NULL; |
| size_t len = 0; |
| objWithStream->GetFilteredStreamRef(&buffer, &len); |
| // TODO(edisonn): really bad hack, find end of object (endobj might be in a comment!) |
| // we need to do now for perf, and our generated pdfs do not have comments, |
| // but we need to remove this hack for pdfs in the wild |
| char* endobj = strrstrk((char*)buffer, (char*)buffer + len, "endobj"); |
| if (endobj) { |
| len = endobj - (char*)buffer + strlen("endobj"); |
| } |
| fUncompressedStreamStart = fUncompressedStream = buffer; |
| fUncompressedStreamEnd = fUncompressedStream + len; |
| } |
| |
| SkPdfNativeTokenizer::SkPdfNativeTokenizer(const unsigned char* buffer, int len, |
| SkPdfAllocator* allocator, |
| SkPdfNativeDoc* doc) : fDoc(doc) |
| , fAllocator(allocator) |
| , fEmpty(false) |
| , fHasPutBack(false) { |
| // TODO(edisonn): really bad hack, find end of object (endobj might be in a comment!) |
| // we need to do now for perf, and our generated pdfs do not have comments, |
| // but we need to remove this hack for pdfs in the wild |
| char* endobj = strrstrk((char*)buffer, (char*)buffer + len, "endobj"); |
| if (endobj) { |
| len = endobj - (char*)buffer + strlen("endobj"); |
| } |
| fUncompressedStreamStart = fUncompressedStream = buffer; |
| fUncompressedStreamEnd = fUncompressedStream + len; |
| } |
| |
| SkPdfNativeTokenizer::~SkPdfNativeTokenizer() { |
| } |
| |
| bool SkPdfNativeTokenizer::readTokenCore(PdfToken* token) { |
| #ifdef PDF_TRACE_READ_TOKEN |
| static int read_op = 0; |
| #endif |
| |
| token->fKeyword = NULL; |
| token->fObject = NULL; |
| |
| fUncompressedStream = skipPdfWhiteSpaces(fUncompressedStream, fUncompressedStreamEnd); |
| if (fUncompressedStream >= fUncompressedStreamEnd) { |
| fEmpty = true; |
| return false; |
| } |
| |
| SkPdfNativeObject obj; |
| fUncompressedStream = nextObject(fUncompressedStream, fUncompressedStreamEnd, &obj, fAllocator, fDoc); |
| // PUT_TRACK_STREAM_ARGS_EXPL2(fStreamId, fUncompressedStreamStart) |
| |
| // If it is a keyword, we will only get the pointer of the string. |
| if (obj.type() == SkPdfNativeObject::kKeyword_PdfObjectType) { |
| token->fKeyword = obj.c_str(); |
| token->fKeywordLength = obj.lenstr(); |
| token->fType = kKeyword_TokenType; |
| } else { |
| SkPdfNativeObject* pobj = fAllocator->allocObject(); |
| *pobj = obj; |
| token->fObject = pobj; |
| token->fType = kObject_TokenType; |
| } |
| |
| #ifdef PDF_TRACE_READ_TOKEN |
| read_op++; |
| #if 0 |
| if (548 == read_op) { |
| printf("break;\n"); |
| } |
| #endif |
| printf("%i READ %s %s\n", read_op, token->fType == kKeyword_TokenType ? "Keyword" : "Object", |
| token->fKeyword ? SkString(token->fKeyword, token->fKeywordLength).c_str() : |
| token->fObject->toString().c_str()); |
| #endif |
| |
| return true; |
| } |
| |
| void SkPdfNativeTokenizer::PutBack(PdfToken token) { |
| SkASSERT(!fHasPutBack); |
| fHasPutBack = true; |
| fPutBack = token; |
| #ifdef PDF_TRACE_READ_TOKEN |
| printf("PUT_BACK %s %s\n", token.fType == kKeyword_TokenType ? "Keyword" : "Object", |
| token.fKeyword ? SkString(token.fKeyword, token.fKeywordLength).c_str() : |
| token.fObject->toString().c_str()); |
| #endif |
| } |
| |
| bool SkPdfNativeTokenizer::readToken(PdfToken* token, bool writeDiff) { |
| if (fHasPutBack) { |
| *token = fPutBack; |
| fHasPutBack = false; |
| #ifdef PDF_TRACE_READ_TOKEN |
| printf("READ_BACK %s %s\n", token->fType == kKeyword_TokenType ? "Keyword" : "Object", |
| token->fKeyword ? SkString(token->fKeyword, token->fKeywordLength).c_str() : |
| token->fObject->toString().c_str()); |
| #endif |
| if (writeDiff) { |
| SkPdfDiffEncoder::WriteToFile(token); |
| } |
| return true; |
| } |
| |
| if (fEmpty) { |
| #ifdef PDF_TRACE_READ_TOKEN |
| printf("EMPTY TOKENIZER\n"); |
| #endif |
| return false; |
| } |
| |
| const bool result = readTokenCore(token); |
| if (result && writeDiff) { |
| SkPdfDiffEncoder::WriteToFile(token); |
| } |
| return result; |
| } |
| |
| #define DECLARE_PDF_NAME(longName) SkPdfName longName((char*)#longName) |
| |
| // keys |
| DECLARE_PDF_NAME(BitsPerComponent); |
| DECLARE_PDF_NAME(ColorSpace); |
| DECLARE_PDF_NAME(Decode); |
| DECLARE_PDF_NAME(DecodeParms); |
| DECLARE_PDF_NAME(Filter); |
| DECLARE_PDF_NAME(Height); |
| DECLARE_PDF_NAME(ImageMask); |
| DECLARE_PDF_NAME(Intent); // PDF 1.1 - the key, or the abBreviations? |
| DECLARE_PDF_NAME(Interpolate); |
| DECLARE_PDF_NAME(Width); |
| |
| // values |
| DECLARE_PDF_NAME(DeviceGray); |
| DECLARE_PDF_NAME(DeviceRGB); |
| DECLARE_PDF_NAME(DeviceCMYK); |
| DECLARE_PDF_NAME(Indexed); |
| DECLARE_PDF_NAME(ASCIIHexDecode); |
| DECLARE_PDF_NAME(ASCII85Decode); |
| DECLARE_PDF_NAME(LZWDecode); |
| DECLARE_PDF_NAME(FlateDecode); // PDF 1.2 |
| DECLARE_PDF_NAME(RunLengthDecode); |
| DECLARE_PDF_NAME(CCITTFaxDecode); |
| DECLARE_PDF_NAME(DCTDecode); |
| |
| #define HANDLE_NAME_ABBR(obj,longName,shortName) if (obj->isName(#shortName)) return &longName; |
| |
| |
| static SkPdfNativeObject* inlineImageKeyAbbreviationExpand(SkPdfNativeObject* key) { |
| if (!key || !key->isName()) { |
| return key; |
| } |
| |
| // TODO(edisonn): use autogenerated code! |
| HANDLE_NAME_ABBR(key, BitsPerComponent, BPC); |
| HANDLE_NAME_ABBR(key, ColorSpace, CS); |
| HANDLE_NAME_ABBR(key, Decode, D); |
| HANDLE_NAME_ABBR(key, DecodeParms, DP); |
| HANDLE_NAME_ABBR(key, Filter, F); |
| HANDLE_NAME_ABBR(key, Height, H); |
| HANDLE_NAME_ABBR(key, ImageMask, IM); |
| // HANDLE_NAME_ABBR(key, Intent, ); |
| HANDLE_NAME_ABBR(key, Interpolate, I); |
| HANDLE_NAME_ABBR(key, Width, W); |
| |
| return key; |
| } |
| |
| static SkPdfNativeObject* inlineImageValueAbbreviationExpand(SkPdfNativeObject* value) { |
| if (!value || !value->isName()) { |
| return value; |
| } |
| |
| // TODO(edisonn): use autogenerated code! |
| HANDLE_NAME_ABBR(value, DeviceGray, G); |
| HANDLE_NAME_ABBR(value, DeviceRGB, RGB); |
| HANDLE_NAME_ABBR(value, DeviceCMYK, CMYK); |
| HANDLE_NAME_ABBR(value, Indexed, I); |
| HANDLE_NAME_ABBR(value, ASCIIHexDecode, AHx); |
| HANDLE_NAME_ABBR(value, ASCII85Decode, A85); |
| HANDLE_NAME_ABBR(value, LZWDecode, LZW); |
| HANDLE_NAME_ABBR(value, FlateDecode, Fl); // (PDF 1.2) |
| HANDLE_NAME_ABBR(value, RunLengthDecode, RL); |
| HANDLE_NAME_ABBR(value, CCITTFaxDecode, CCF); |
| HANDLE_NAME_ABBR(value, DCTDecode, DCT); |
| |
| return value; |
| } |
| |
| SkPdfImageDictionary* SkPdfNativeTokenizer::readInlineImage() { |
| // BI already processed |
| fUncompressedStream = skipPdfWhiteSpaces(fUncompressedStream, fUncompressedStreamEnd); |
| if (fUncompressedStream >= fUncompressedStreamEnd) { |
| return NULL; |
| } |
| |
| SkPdfImageDictionary* inlineImage = (SkPdfImageDictionary*)fAllocator->allocObject(); |
| SkPdfNativeObject::makeEmptyDictionary(inlineImage); |
| // PUT_TRACK_STREAM_ARGS_EXPL(fStreamId, fUncompressedStream - fUncompressedStreamStart, |
| // fUncompressedStream - fUncompressedStreamStart) |
| |
| while (fUncompressedStream < fUncompressedStreamEnd) { |
| SkPdfNativeObject* key = fAllocator->allocObject(); |
| fUncompressedStream = nextObject(fUncompressedStream, fUncompressedStreamEnd, key, |
| fAllocator, fDoc); |
| // PUT_TRACK_STREAM_ARGS_EXPL2(fStreamId, fUncompressedStreamStart)s |
| |
| if (key->isKeyword() && key->lenstr() == 2 && |
| key->c_str()[0] == 'I' && key->c_str()[1] == 'D') { // ID |
| fUncompressedStream = readInlineImageStream(fUncompressedStream, fUncompressedStreamEnd, |
| inlineImage, fDoc); |
| return inlineImage; |
| } else { |
| SkPdfNativeObject* obj = fAllocator->allocObject(); |
| fUncompressedStream = nextObject(fUncompressedStream, fUncompressedStreamEnd, obj, |
| fAllocator, fDoc); |
| // PUT_TRACK_STREAM_ARGS_EXPL2(fStreamId, fUncompressedStreamStart)s |
| // TODO(edisonn): perf maybe we should not expand abBreviation like this |
| inlineImage->set(inlineImageKeyAbbreviationExpand(key), |
| inlineImageValueAbbreviationExpand(obj)); |
| } |
| } |
| // TODO(edisonn): report end of data with inline image without an EI |
| return inlineImage; |
| } |
