void draw(SkCanvas*) {
constexpr SkSize ansiLetterSize{8.5f * 72, 11.0f * 72};
SkDynamicMemoryWStream buffer;
WritePDF(&buffer, "SkPDF Example", &write_page, 1, ansiLetterSize);
sk_sp<SkData> pdfData = buffer.detachAsData();
print_data(pdfData.get(), "skpdf_example.pdf");
}
DEF_TEST(SkPDF_unicode_metadata, r) {
REQUIRE_PDF_DOCUMENT(SkPDF_unicode_metadata, r);
SkPDF::Metadata pdfMetadata;
pdfMetadata.fTitle = "𝓐𝓑𝓒𝓓𝓔 𝓕𝓖𝓗𝓘𝓙"; // Out of basic multilingual plane
pdfMetadata.fAuthor = "ABCDE FGHIJ"; // ASCII
pdfMetadata.fSubject = "αβγδε ζηθικ"; // inside basic multilingual plane
pdfMetadata.fPDFA = true;
SkDynamicMemoryWStream wStream;
{
auto doc = SkPDF::MakeDocument(&wStream, pdfMetadata);
doc->beginPage(612, 792)->drawColor(SK_ColorCYAN);
}
sk_sp<SkData> data(wStream.detachAsData());
static const char* expectations[] = {
"<</Title <FEFFD835DCD0D835DCD1D835DCD2D835DCD3D835DCD40020"
"D835DCD5D835DCD6D835DCD7D835DCD8D835DCD9>",
"/Author (ABCDE FGHIJ)",
"Subject <FEFF03B103B203B303B403B5002003B603B703B803B903BA>",
};
for (const char* expectation : expectations) {
if (!contains(data->bytes(), data->size(), expectation)) {
ERRORF(r, "PDF expectation missing: '%s'.", expectation);
}
}
}
// verify that the PDFA flag does something.
DEF_TEST(SkPDF_pdfa_document, r) {
REQUIRE_PDF_DOCUMENT(SkPDF_pdfa_document, r);
SkPDF::Metadata pdfMetadata;
pdfMetadata.fTitle = "test document";
pdfMetadata.fCreation = {0, 1999, 12, 5, 31, 23, 59, 59};
pdfMetadata.fPDFA = true;
SkDynamicMemoryWStream buffer;
auto doc = SkPDF::MakeDocument(&buffer, pdfMetadata);
doc->beginPage(64, 64)->drawColor(SK_ColorRED);
doc->close();
sk_sp<SkData> data(buffer.detachAsData());
static const char* expectations[] = {
"sRGB IEC61966-2.1",
"<dc:title><rdf:Alt><rdf:li xml:lang=\"x-default\">test document",
"<xmp:CreateDate>1999-12-31T23:59:59+00:00</xmp:CreateDate>",
"/Subtype /XML",
"/CreationDate (D:19991231235959+00'00')>>",
};
for (const char* expectation : expectations) {
if (!contains(data->bytes(), data->size(), expectation)) {
ERRORF(r, "PDFA expectation missing: '%s'.", expectation);
}
}
pdfMetadata.fProducer = "phoney library";
pdfMetadata.fPDFA = true;
doc = SkPDF::MakeDocument(&buffer, pdfMetadata);
doc->beginPage(64, 64)->drawColor(SK_ColorRED);
doc->close();
data = buffer.detachAsData();
static const char* moreExpectations[] = {
"/Producer (phoney library)",
"/ProductionLibrary (Skia/PDF m",
"<!-- <skia:ProductionLibrary>Skia/PDF m",
"<pdf:Producer>phoney library</pdf:Producer>",
};
for (const char* expectation : moreExpectations) {
if (!contains(data->bytes(), data->size(), expectation)) {
ERRORF(r, "PDFA expectation missing: '%s'.", expectation);
}
}
}
sk_sp<SkData> Request::getJsonBatchList(int n) {
SkCanvas* canvas = this->getCanvas();
SkASSERT(fGPUEnabled);
Json::Value result = fDebugCanvas->toJSONBatchList(n, canvas);
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(result).c_str());
return stream.detachAsData();
}
sk_sp<SkData> Request::getJsonOps(int n) {
SkCanvas* canvas = this->getCanvas();
Json::Value root = fDebugCanvas->toJSON(fUrlDataManager, n, canvas);
root["mode"] = Json::Value(fGPUEnabled ? "gpu" : "cpu");
root["drawGpuBatchBounds"] = Json::Value(fDebugCanvas->getDrawGpuBatchBounds());
root["colorMode"] = Json::Value(fColorMode);
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(root).c_str());
return stream.detachAsData();
}
sk_sp<SkData> Request::writeCanvasToPng(SkCanvas* canvas) {
// capture pixels
SkAutoTDelete<SkBitmap> bmp(this->getBitmapFromCanvas(canvas));
SkASSERT(bmp);
// Convert to format suitable for PNG output
sk_sp<SkData> encodedBitmap = sk_tools::encode_bitmap_for_png(*bmp);
SkASSERT(encodedBitmap.get());
// write to an opaque png (black background)
SkDynamicMemoryWStream buffer;
SkDrawCommand::WritePNG(encodedBitmap->bytes(), bmp->width(), bmp->height(),
buffer, true);
return buffer.detachAsData();
}
SkData* onEncode(const SkPixmap& pmap) {
if (kAlpha_8_SkColorType == pmap.colorType()) {
SkDynamicMemoryWStream stream;
stream.write("skiaimgf", 8);
stream.write32(pmap.width());
stream.write32(pmap.height());
stream.write16(pmap.colorType());
stream.write16(pmap.alphaType());
stream.write32(0); // no colorspace for now
for (int y = 0; y < pmap.height(); ++y) {
stream.write(pmap.addr8(0, y), pmap.width());
}
return stream.detachAsData().release();
}
return nullptr;
}
static void stream_copy_test(skiatest::Reporter* reporter,
const void* srcData,
size_t N,
SkStream* stream) {
SkDynamicMemoryWStream tgt;
if (!SkStreamCopy(&tgt, stream)) {
ERRORF(reporter, "SkStreamCopy failed");
return;
}
sk_sp<SkData> data(tgt.detachAsData());
if (data->size() != N) {
ERRORF(reporter, "SkStreamCopy incorrect size");
return;
}
if (0 != memcmp(data->data(), srcData, N)) {
ERRORF(reporter, "SkStreamCopy bad copy");
}
}
sk_sp<SkData> Request::writeOutSkp() {
// Playback into picture recorder
SkIRect bounds = this->getBounds();
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(bounds.width()),
SkIntToScalar(bounds.height()));
fDebugCanvas->draw(canvas);
sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
SkDynamicMemoryWStream outStream;
SkAutoTUnref<SkPixelSerializer> serializer(SkImageEncoder::CreatePixelSerializer());
picture->serialize(&outStream, serializer);
return outStream.detachAsData();
}
DEF_TEST(DynamicMemoryWStream_detachAsData, r) {
const char az[] = "abcdefghijklmnopqrstuvwxyz";
const unsigned N = 40000;
SkDynamicMemoryWStream dmws;
for (unsigned i = 0; i < N; ++i) {
dmws.writeText(az);
}
REPORTER_ASSERT(r, dmws.bytesWritten() == N * strlen(az));
auto data = dmws.detachAsData();
REPORTER_ASSERT(r, data->size() == N * strlen(az));
const uint8_t* ptr = data->bytes();
for (unsigned i = 0; i < N; ++i) {
if (0 != memcmp(ptr, az, strlen(az))) {
ERRORF(r, "detachAsData() memcmp failed");
return;
}
ptr += strlen(az);
}
}
static sk_sp<SkData> encode(SkTypeface* tf) {
SkDynamicMemoryWStream stream;
tf->serialize(&stream);
return sk_sp<SkData>(stream.detachAsData());
}
sk_sp<SkData> SkPipeSerializer::writePicture(SkPicture* picture) {
SkDynamicMemoryWStream stream;
this->writePicture(picture, &stream);
return stream.detachAsData();
}
sk_sp<SkData> SkPipeSerializer::writeImage(SkImage* image) {
SkDynamicMemoryWStream stream;
this->writeImage(image, &stream);
return stream.detachAsData();
}
int BreakHandler::handle(Request* request, MHD_Connection* connection,
const char* url, const char* method,
const char* upload_data, size_t* upload_data_size) {
SkTArray<SkString> commands;
SkStrSplit(url, "/", &commands);
if (!request->hasPicture() || commands.count() != 4) {
return MHD_NO;
}
// /break/<n>/<x>/<y>
int n;
sscanf(commands[1].c_str(), "%d", &n);
int x;
sscanf(commands[2].c_str(), "%d", &x);
int y;
sscanf(commands[3].c_str(), "%d", &y);
int count = request->fDebugCanvas->getSize();
SkASSERT(n < count);
SkCanvas* canvas = request->getCanvas();
canvas->clear(SK_ColorWHITE);
int saveCount = canvas->save();
for (int i = 0; i <= n; ++i) {
request->fDebugCanvas->getDrawCommandAt(i)->execute(canvas);
}
SkColor target = request->getPixel(x, y);
SkDynamicMemoryWStream stream;
SkJSONWriter writer(&stream, SkJSONWriter::Mode::kFast);
writer.beginObject(); // root
writer.appendName("startColor");
DrawCommand::MakeJsonColor(writer, target);
bool changed = false;
for (int i = n + 1; i < n + count; ++i) {
int index = i % count;
if (index == 0) {
// reset canvas for wraparound
canvas->restoreToCount(saveCount);
canvas->clear(SK_ColorWHITE);
saveCount = canvas->save();
}
request->fDebugCanvas->getDrawCommandAt(index)->execute(canvas);
SkColor current = request->getPixel(x, y);
if (current != target) {
writer.appendName("endColor");
DrawCommand::MakeJsonColor(writer, current);
writer.appendS32("endOp", index);
changed = true;
break;
}
}
if (!changed) {
writer.appendName("endColor");
DrawCommand::MakeJsonColor(writer, target);
writer.appendS32("endOp", n);
}
canvas->restoreToCount(saveCount);
writer.endObject(); // root
writer.flush();
return SendData(connection, stream.detachAsData().get(), "application/json");
}
