SkPDFTypes.cpp File Reference

#include "src/pdf/SkPDFTypes.h"
#include "include/core/SkExecutor.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/docs/SkPDFDocument.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkUTF.h"
#include "src/base/SkUtils.h"
#include "src/core/SkStreamPriv.h"
#include "src/pdf/SkDeflate.h"
#include "src/pdf/SkPDFDocumentPriv.h"
#include "src/pdf/SkPDFUnion.h"
#include "src/pdf/SkPDFUtils.h"
#include <cstring>
#include <functional>
#include <new>

Go to the source code of this file.

Functions
static void	write_name_escaped (SkWStream *o, const char *name)
static void	write_literal_byte_string (SkWStream *wStream, const char *cin, size_t len)
static void	write_hex_byte_string (SkWStream *wStream, const char *cin, size_t len)
static void	write_optimized_byte_string (SkWStream *wStream, const char *cin, size_t len, size_t literalExtras)
static void	write_byte_string (SkWStream *wStream, const char *cin, size_t len)
static void	write_text_string (SkWStream *wStream, const char *cin, size_t len)
void	SkPDFWriteTextString (SkWStream *wStream, const char *cin, size_t len)
void	SkPDFWriteByteString (SkWStream *wStream, const char *cin, size_t len)
static void	serialize_stream (SkPDFDict *origDict, SkStreamAsset *stream, SkPDFSteamCompressionEnabled compress, SkPDFDocument *doc, SkPDFIndirectReference ref)
SkPDFIndirectReference	SkPDFStreamOut (std::unique_ptr< SkPDFDict > dict, std::unique_ptr< SkStreamAsset > content, SkPDFDocument *doc, SkPDFSteamCompressionEnabled compress)

Function Documentation

serialize_stream()

static void serialize_stream ( SkPDFDict *  origDict, SkStreamAsset *  stream, SkPDFSteamCompressionEnabled  compress, SkPDFDocument *  doc, SkPDFIndirectReference  ref  )

static

Definition at line 544 of file SkPDFTypes.cpp.

                                                         {
    // Code assumes that the stream starts at the beginning.
    SkASSERT(stream && stream->hasLength());
 
    std::unique_ptr<SkStreamAsset> tmp;
    SkPDFDict tmpDict;
    SkPDFDict& dict = origDict ? *origDict : tmpDict;
    static const size_t kMinimumSavings = strlen("/Filter_/FlateDecode_");
    if (doc->metadata().fCompressionLevel != SkPDF::Metadata::CompressionLevel::None &&
        compress == SkPDFSteamCompressionEnabled::Yes &&
        stream->getLength() > kMinimumSavings)
    {
        SkDynamicMemoryWStream compressedData;
        SkDeflateWStream deflateWStream(&compressedData,SkToInt(doc->metadata().fCompressionLevel));
        SkStreamCopy(&deflateWStream, stream);
        deflateWStream.finalize();
        #ifdef SK_PDF_BASE85_BINARY
        {
            SkPDFUtils::Base85Encode(compressedData.detachAsStream(), &compressedData);
            tmp = compressedData.detachAsStream();
            stream = tmp.get();
            auto filters = SkPDFMakeArray();
            filters->appendName("ASCII85Decode");
            filters->appendName("FlateDecode");
            dict.insertObject("Filter", std::move(filters));
        }
        #else
        if (stream->getLength() > compressedData.bytesWritten() + kMinimumSavings) {
            tmp = compressedData.detachAsStream();
            stream = tmp.get();
            dict.insertName("Filter", "FlateDecode");
        } else {
            SkAssertResult(stream->rewind());
        }
        #endif
 
    }
    dict.insertInt("Length", stream->getLength());
    doc->emitStream(dict,
                    [stream](SkWStream* dst) { dst->writeStream(stream, stream->getLength()); },
                    ref);
}

SkPDFStreamOut()

SkPDFIndirectReference SkPDFStreamOut	(	std::unique_ptr< SkPDFDict >	dict,
		std::unique_ptr< SkStreamAsset >	content,
		SkPDFDocument *	doc,
		SkPDFSteamCompressionEnabled	compress
	)

Definition at line 591 of file SkPDFTypes.cpp.

                                                                             {
    SkPDFIndirectReference ref = doc->reserveRef();
    if (SkExecutor* executor = doc->executor()) {
        SkPDFDict* dictPtr = dict.release();
        SkStreamAsset* contentPtr = content.release();
        // Pass ownership of both pointers into a std::function, which should
        // only be executed once.
        doc->incrementJobCount();
        executor->add([dictPtr, contentPtr, compress, doc, ref]() {
            serialize_stream(dictPtr, contentPtr, compress, doc, ref);
            delete dictPtr;
            delete contentPtr;
            doc->signalJobComplete();
        });
        return ref;
    }
    serialize_stream(dict.get(), content.get(), compress, doc, ref);
    return ref;
}

SkPDFWriteByteString()

void SkPDFWriteByteString	(	SkWStream *	wStream,
		const char *	cin,
		size_t	len
	)

Definition at line 248 of file SkPDFTypes.cpp.

                                                                           {
    write_byte_string(wStream, cin, len);
}

SkPDFWriteTextString()

void SkPDFWriteTextString	(	SkWStream *	wStream,
		const char *	cin,
		size_t	len
	)

Definition at line 245 of file SkPDFTypes.cpp.

                                                                           {
    write_text_string(wStream, cin, len);
}

write_byte_string()

static void write_byte_string ( SkWStream *  wStream, const char *  cin, size_t  len  )

static

Definition at line 176 of file SkPDFTypes.cpp.

                                                                               {
    SkDEBUGCODE(static const size_t kMaxLen = 65535;)
    SkASSERT(len <= kMaxLen);
 
    size_t literalExtras = 0;
    {
        for (size_t i = 0; i < len; i++) {
            uint8_t c = static_cast<uint8_t>(cin[i]);
            if (c < ' ' || '~' < c) {
                literalExtras += 3;
            } else if (c == '\\' || c == '(' || c == ')') {
                ++literalExtras;
            }
        }
    }
    write_optimized_byte_string(wStream, cin, len, literalExtras);
}

write_hex_byte_string()

static void write_hex_byte_string ( SkWStream *  wStream, const char *  cin, size_t  len  )

static

Definition at line 151 of file SkPDFTypes.cpp.

                                                                                   {
    SkDEBUGCODE(static const size_t kMaxLen = 65535;)
    SkASSERT(len <= kMaxLen);
 
    wStream->writeText("<");
    for (size_t i = 0; i < len; i++) {
        uint8_t c = static_cast<uint8_t>(cin[i]);
        char hexValue[2] = { SkHexadecimalDigits::gUpper[c >> 4],
                             SkHexadecimalDigits::gUpper[c & 0xF] };
        wStream->write(hexValue, 2);
    }
    wStream->writeText(">");
}

write_literal_byte_string()

static void write_literal_byte_string ( SkWStream *  wStream, const char *  cin, size_t  len  )

static

Definition at line 131 of file SkPDFTypes.cpp.

                                                                                       {
    wStream->writeText("(");
    for (size_t i = 0; i < len; i++) {
        uint8_t c = static_cast<uint8_t>(cin[i]);
        if (c < ' ' || '~' < c) {
            uint8_t octal[4] = { '\\',
                                 (uint8_t)('0' | ( c >> 6        )),
                                 (uint8_t)('0' | ((c >> 3) & 0x07)),
                                 (uint8_t)('0' | ( c       & 0x07)) };
            wStream->write(octal, 4);
        } else {
            if (c == '\\' || c == '(' || c == ')') {
                wStream->writeText("\\");
            }
            wStream->write(&c, 1);
        }
    }
    wStream->writeText(")");
}

write_name_escaped()

static void write_name_escaped ( SkWStream *  o, const char *  name  )

static

Definition at line 116 of file SkPDFTypes.cpp.

                                                               {
    static const char kToEscape[] = "#/%()<>[]{}";
    for (const uint8_t* n = reinterpret_cast<const uint8_t*>(name); *n; ++n) {
        uint8_t v = *n;
        if (v < '!' || v > '~' || strchr(kToEscape, v)) {
            char buffer[3] = {'#',
                              SkHexadecimalDigits::gUpper[v >> 4],
                              SkHexadecimalDigits::gUpper[v & 0xF]};
            o->write(buffer, sizeof(buffer));
        } else {
            o->write(n, 1);
        }
    }
}

write_optimized_byte_string()

static void write_optimized_byte_string ( SkWStream *  wStream, const char *  cin, size_t  len, size_t  literalExtras  )

static

Definition at line 165 of file SkPDFTypes.cpp.

                                                              {
    const size_t hexLength     = 2 + 2*len;
    const size_t literalLength = 2 +   len + literalExtras;
    if (literalLength <= hexLength) {
        write_literal_byte_string(wStream, cin, len);
    } else {
        write_hex_byte_string(wStream, cin, len);
    }
}

write_text_string()

static void write_text_string ( SkWStream *  wStream, const char *  cin, size_t  len  )

static

Definition at line 194 of file SkPDFTypes.cpp.

                                                                               {
    SkDEBUGCODE(static const size_t kMaxLen = 65535;)
    SkASSERT(len <= kMaxLen);
 
    bool inputIsValidUTF8 = true;
    bool inputIsPDFDocEncoding = true;
    size_t literalExtras = 0;
    {
        const char* textPtr = cin;
        const char* textEnd = cin + len;
        while (textPtr < textEnd) {
            SkUnichar unichar = SkUTF::NextUTF8(&textPtr, textEnd);
            if (unichar < 0) {
                inputIsValidUTF8 = false;
                break;
            }
            // See Table D.2 (PDFDocEncoding Character Set) in the PDF3200_2008 spec.
            // Could convert from UTF-8 to PDFDocEncoding and, if successful, use that.
            if ((0x15 < unichar && unichar < 0x20) || 0x7E < unichar) {
                inputIsPDFDocEncoding = false;
                break;
            }
            if (unichar < ' ' || '~' < unichar) {
                literalExtras += 3;
            } else if (unichar == '\\' || unichar == '(' || unichar == ')') {
                ++literalExtras;
            }
        }
    }
 
    if (!inputIsValidUTF8) {
        SkDebugf("Invalid UTF8: %.*s\n", (int)len, cin);
        wStream->writeText("<>");
        return;
    }
 
    if (inputIsPDFDocEncoding) {
        write_optimized_byte_string(wStream, cin, len, literalExtras);
        return;
    }
 
    wStream->writeText("<FEFF");
    const char* textPtr = cin;
    const char* textEnd = cin + len;
    while (textPtr < textEnd) {
        SkUnichar unichar = SkUTF::NextUTF8(&textPtr, textEnd);
        SkPDFUtils::WriteUTF16beHex(wStream, unichar);
    }
    wStream->writeText(">");
}