TEST(Test1, pngWriteDataToMemory) {
std::cout << "########## Image memory write" << std::endl;
PngReader pngReaderFromFile;
FilePngInputStream filePngInputStream(IMAGE1);
pngReaderFromFile.readFromInputstream(filePngInputStream);
Chrono chrono;
PngData pngData(pngReaderFromFile.getWidth(), pngReaderFromFile.getHeight(),
pngReaderFromFile.getBitDepth(), pngReaderFromFile.getColorType(),
pngReaderFromFile.getPixelDataRowPointers());
PngWriter writer(pngData);
MemoryPngOutputStream memOs;
writer.writePngToOutputStream(memOs);
std::cout << "Image write png to memory in " << chrono.elapsedTimeInMs()
<< " ms, nrOfBytes=" << memOs.getNrOfBytes() << std::endl;
// Read the data written to memory, and check against the original
MemoryPngInputStream memoryInputstream(memOs.getBuffer().data(),
memOs.getNrOfBytes());
PngReader pngReaderFromMemory;
pngReaderFromMemory.readFromInputstream(memoryInputstream);
AssertUtil::equals(pngReaderFromFile, pngReaderFromMemory);
}
void SkSVGDevice::drawBitmapCommon(const SkDraw& draw, const SkBitmap& bm,
const SkPaint& paint) {
SkAutoTUnref<const SkData> pngData(
SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, SkImageEncoder::kDefaultQuality));
if (!pngData) {
return;
}
size_t b64Size = SkBase64::Encode(pngData->data(), pngData->size(), NULL);
SkAutoTMalloc<char> b64Data(b64Size);
SkBase64::Encode(pngData->data(), pngData->size(), b64Data.get());
SkString svgImageData("data:image/png;base64,");
svgImageData.append(b64Data.get(), b64Size);
SkString imageID = fResourceBucket->addImage();
{
AutoElement defs("defs", fWriter);
{
AutoElement image("image", fWriter);
image.addAttribute("id", imageID);
image.addAttribute("width", bm.width());
image.addAttribute("height", bm.height());
image.addAttribute("xlink:href", svgImageData);
}
}
{
AutoElement imageUse("use", fWriter, fResourceBucket, draw, paint);
imageUse.addAttribute("xlink:href", SkStringPrintf("#%s", imageID.c_str()));
}
}
TEST(Test1, pngWriteDataToMemoryDefaultAndPrealloc) {
std::cout << "########## Image memory write" << std::endl;
PngReader pngReaderFromFile;
FilePngInputStream filePngInputStream(IMAGE1);
pngReaderFromFile.readFromInputstream(filePngInputStream);
Chrono chrono;
PngData pngData(pngReaderFromFile.getWidth(), pngReaderFromFile.getHeight(),
pngReaderFromFile.getBitDepth(), pngReaderFromFile.getColorType(),
pngReaderFromFile.getPixelDataRowPointers());
std::cout << "Number of bytes pixelData=" << pngData.getNrOfBytesPixelData() << std::endl;
MemoryPngOutputStream memOs1;
{
PngWriter writer(pngData);
writer.writePngToOutputStream(memOs1);
std::cout << "Image write png to memory (no pre-alloc) in " << chrono.elapsedTimeInMs()
<< " ms, nrOfBytes=" << memOs1.getNrOfBytes() << std::endl;
}
{
PngWriter writer(pngData);
const uint32_t estimatedPngHeaderSize= 512;
uint32_t outputBufferSize = pngData.getNrOfBytesPixelData() + estimatedPngHeaderSize;
MemoryPngOutputStream memOs2(outputBufferSize);
writer.writePngToOutputStream(memOs2);
std::cout << "Image write png to memory (pre-alloc) in " << chrono.elapsedTimeInMs()
<< " ms, nrOfBytes=" << memOs2.getNrOfBytes() << std::endl;
EXPECT_EQ(memOs1.getNrOfBytes(), memOs2.getNrOfBytes());
}
}
int main(int argc, char **argv) {
if (argc < 2) {
std::cout << "Usage: pgn-app png-in" << std::endl;
return 1;
}
Chrono chrono;
chrono.reset();
IOUtils png;
png.readFile(argv[1]);
MemoryPngInputStream memoryInputstream((const png_bytep) png.getBuffer(),
(const png_size_t) png.getLength());
std::cout << "Image read info memory in " << chrono.elapsedTimeInMs()
<< " ms" << std::endl;
{
chrono.reset();
PngReader rdrMem;
memoryInputstream.reset();
rdrMem.readFromInputstream(memoryInputstream, true);
std::cout << "Image read memory (own alloc)in "
<< chrono.elapsedTimeInMs() << " ms" << std::endl;
}
chrono.reset();
PngReader rdrMem;
memoryInputstream.reset();
rdrMem.readFromInputstream(memoryInputstream);
std::cout << "Image read memory (pnglib alloc) in "
<< chrono.elapsedTimeInMs() << " ms" << std::endl;
PngData pngData(rdrMem.getWidth(), rdrMem.getHeight(), rdrMem.getBitDepth(),
rdrMem.getColorType(), rdrMem.getPixelDataRowPointers());
std::cout << "Nr of bytes pixelData=" << pngData.getNrOfBytesPixelData()
<< std::endl;
// Loop to see if having a preallocated buffer works better. Answer: yes
// Saving was 0-20 ms (on VM on Laptop: (windows7,[email protected] ghz, 8gb)
const uint32_t estimatedPngHeaderSize = 1024 * 8;
for (int j = 0; j < 10; j++) {
for (uint32_t i = 0; i < 2; i++) {
uint32_t outputBufferSize = pngData.getNrOfBytesPixelData()
+ estimatedPngHeaderSize;
MemoryPngOutputStream memOs(i * outputBufferSize);
chrono.reset();
PngWriter writer(pngData);
writer.writePngToOutputStream(memOs);
std::cout << "Iteration: " << i << ", image write png to memory in "
<< chrono.elapsedTimeInMs() << " ms and has size "
<< memOs.getNrOfBytes() << " bytes" << std::endl;
}
}
return 0;
}
void ICOImageDecoder::setDataForPNGDecoderAtIndex(size_t index)
{
if (!m_pngDecoders[index])
return;
const IconDirectoryEntry& dirEntry = m_dirEntries[index];
// Copy out PNG data to a separate vector and send to the PNG decoder.
// FIXME: Save this copy by making the PNG decoder able to take an
// optional offset.
RefPtr<SharedBuffer> pngData(SharedBuffer::create(&m_data->data()[dirEntry.m_imageOffset], m_data->size() - dirEntry.m_imageOffset));
m_pngDecoders[index]->setData(pngData.get(), isAllDataReceived());
}
