PNGImageEncoder.cpp [plain text]
#include "config.h"
#include "IntSize.h"
#include "OwnArrayPtr.h"
#include "PNGImageEncoder.h"
#include "Vector.h"
#include "SkBitmap.h"
extern "C" {
#include "png.h"
}
namespace WebCore {
static void convertBetweenBGRAandRGBA(const unsigned char* input, int numberOfPixels,
unsigned char* output)
{
for (int x = 0; x < numberOfPixels; x++) {
const unsigned char* pixelIn = &input[x * 4];
unsigned char* pixelOut = &output[x * 4];
pixelOut[0] = pixelIn[2];
pixelOut[1] = pixelIn[1];
pixelOut[2] = pixelIn[0];
pixelOut[3] = pixelIn[3];
}
}
struct PNGEncoderState {
PNGEncoderState(Vector<unsigned char>* o) : m_out(o) {}
Vector<unsigned char>* m_out;
};
void encoderWriteCallback(png_structp png, png_bytep data, png_size_t size)
{
PNGEncoderState* state = static_cast<PNGEncoderState*>(png_get_io_ptr(png));
ASSERT(state->m_out);
size_t oldSize = state->m_out->size();
state->m_out->resize(oldSize + size);
memcpy(&(*state->m_out)[oldSize], data, size);
}
class PNGWriteStructDestroyer {
public:
PNGWriteStructDestroyer(png_struct** ps, png_info** pi)
: m_pngStruct(ps)
, m_pngInfo(pi) {
}
~PNGWriteStructDestroyer() {
png_destroy_write_struct(m_pngStruct, m_pngInfo);
}
private:
png_struct** m_pngStruct;
png_info** m_pngInfo;
};
bool PNGImageEncoder::encode(const SkBitmap& image, Vector<unsigned char>* output)
{
if (image.config() != SkBitmap::kARGB_8888_Config)
return false;
image.lockPixels();
bool result = PNGImageEncoder::encode(static_cast<unsigned char*>(
image.getPixels()), IntSize(image.width(), image.height()),
image.rowBytes(), output);
image.unlockPixels();
return result;
}
bool PNGImageEncoder::encode(const unsigned char* input, const IntSize& size,
int bytesPerRow,
Vector<unsigned char>* output)
{
int inputColorComponents = 4;
int outputColorComponents = 4;
int pngOutputColorType = PNG_COLOR_TYPE_RGB_ALPHA;
IntSize imageSize(size);
imageSize.clampNegativeToZero();
if (inputColorComponents * imageSize.width() > bytesPerRow) {
ASSERT(false);
return false;
}
png_struct* pngPtr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
if (!pngPtr)
return false;
png_info* infoPtr = png_create_info_struct(pngPtr);
if (!infoPtr) {
png_destroy_write_struct(&pngPtr, NULL);
return false;
}
PNGWriteStructDestroyer destroyer(&pngPtr, &infoPtr);
if (setjmp(png_jmpbuf(pngPtr))) {
return false;
}
PNGEncoderState state(output);
png_set_write_fn(pngPtr, &state, encoderWriteCallback, NULL);
png_set_IHDR(pngPtr, infoPtr, imageSize.width(), imageSize.height(), 8, pngOutputColorType,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
png_write_info(pngPtr, infoPtr);
OwnArrayPtr<unsigned char> rowPixels(new unsigned char[imageSize.width() * outputColorComponents]);
for (int y = 0; y < imageSize.height(); y ++) {
convertBetweenBGRAandRGBA(&input[y * bytesPerRow], imageSize.width(), rowPixels.get());
png_write_row(pngPtr, rowPixels.get());
}
png_write_end(pngPtr, infoPtr);
return true;
}
}