static gboolean
gst_webp_set_picture_params (GstWebpEnc * enc)
{
GstVideoInfo *info;
gboolean ret = TRUE;
info = &enc->input_state->info;
if (!WebPPictureInit (&enc->webp_picture)) {
ret = FALSE;
goto failed_pic_init;
}
enc->webp_picture.use_argb = enc->use_argb;
if (!enc->use_argb)
enc->webp_picture.colorspace = enc->webp_color_space;
enc->webp_picture.width = GST_VIDEO_INFO_WIDTH (info);
enc->webp_picture.height = GST_VIDEO_INFO_HEIGHT (info);
WebPMemoryWriterInit (&enc->webp_writer);
enc->webp_picture.writer = WebPMemoryWrite;
enc->webp_picture.custom_ptr = &enc->webp_writer;
return ret;
failed_pic_init:
{
GST_ERROR_OBJECT (enc, "Failed to Initialize WebPPicture !");
return ret;
}
}
static bool encodePixels(IntSize imageSize, const unsigned char* pixels, bool premultiplied, int quality, Vector<unsigned char>* output)
{
if (imageSize.width() <= 0 || imageSize.width() > WEBP_MAX_DIMENSION)
return false;
if (imageSize.height() <= 0 || imageSize.height() > WEBP_MAX_DIMENSION)
return false;
WebPConfig config;
if (!WebPConfigInit(&config))
return false;
WebPPicture picture;
if (!WebPPictureInit(&picture))
return false;
picture.width = imageSize.width();
picture.height = imageSize.height();
if (premultiplied && !platformPremultipliedImportPicture(pixels, &picture))
return false;
if (!premultiplied && !importPictureRGBX<false>(pixels, &picture))
return false;
picture.custom_ptr = output;
picture.writer = &writeOutput;
config.quality = quality;
config.method = 3;
bool success = WebPEncode(&config, &picture);
WebPPictureFree(&picture);
return success;
}
static size_t encode(const uint8_t* rgba, int width, int height,
uint8_t** output)
{
WebPPicture pic;
WebPConfig config;
WebPMemoryWriter wrt;
int ok;
if (!WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, 100) ||
!WebPPictureInit(&pic))
{
return 0;
}
config.lossless = true;
config.method = 6;
pic.use_argb = true;
pic.width = width;
pic.height = height;
pic.writer = WebPMemoryWrite;
pic.custom_ptr = &wrt;
WebPMemoryWriterInit(&wrt);
ok = WebPPictureImportRGBA(&pic, rgba, width * 4) &&
WebPEncode(&config, &pic);
WebPPictureFree(&pic);
if (!ok)
return 0;
*output = wrt.mem;
return wrt.size;
}
int WebPPictureDistortion(const WebPPicture* src, const WebPPicture* ref,
int type, float results[5]) {
int w, h, c;
int ok = 0;
WebPPicture p0, p1;
double total_size = 0., total_distortion = 0.;
if (src == NULL || ref == NULL ||
src->width != ref->width || src->height != ref->height ||
results == NULL) {
return 0;
}
VP8SSIMDspInit();
if (!WebPPictureInit(&p0) || !WebPPictureInit(&p1)) return 0;
w = src->width;
h = src->height;
if (!WebPPictureView(src, 0, 0, w, h, &p0)) goto Error;
if (!WebPPictureView(ref, 0, 0, w, h, &p1)) goto Error;
// We always measure distortion in ARGB space.
if (p0.use_argb == 0 && !WebPPictureYUVAToARGB(&p0)) goto Error;
if (p1.use_argb == 0 && !WebPPictureYUVAToARGB(&p1)) goto Error;
for (c = 0; c < 4; ++c) {
float distortion;
const size_t stride0 = 4 * (size_t)p0.argb_stride;
const size_t stride1 = 4 * (size_t)p1.argb_stride;
if (!WebPPlaneDistortion((const uint8_t*)p0.argb + c, stride0,
(const uint8_t*)p1.argb + c, stride1,
w, h, 4, type, &distortion, results + c)) {
goto Error;
}
total_distortion += distortion;
total_size += w * h;
}
results[4] = (type == 1) ? (float)GetLogSSIM(total_distortion, total_size)
: (float)GetPSNR(total_distortion, total_size);
ok = 1;
Error:
WebPPictureFree(&p0);
WebPPictureFree(&p1);
return ok;
}
bool
WebpOutput::open (const std::string &name, const ImageSpec &spec,
OpenMode mode)
{
if (mode != Create) {
error ("%s does not support subimages or MIP levels", format_name());
return false;
}
// saving 'name' and 'spec' for later use
m_filename = name;
stash_spec(spec);
m_file = fopen (m_filename.c_str (), "wb");
if (!m_file) {
error ("Unable to open file \"%s\"", m_filename.c_str ());
return false;
}
if (!WebPPictureInit(&m_webp_picture))
{
error("Couldn't initialize WebPPicture\n");
close();
return false;
}
m_webp_picture.width = m_spec.width;
m_webp_picture.height = m_spec.height;
m_webp_picture.writer = WebpImageWriter;
m_webp_picture.custom_ptr = (void*)m_file;
if (!WebPConfigInit(&m_webp_config))
{
error("Couldn't initialize WebPPicture\n");
close();
return false;
}
m_webp_config.method = 6;
int compression_quality = 100;
const ImageIOParameter *qual = m_spec.find_attribute ("CompressionQuality",
TypeDesc::INT);
if (qual)
{
compression_quality = *static_cast<const int*>(qual->data());
}
m_webp_config.quality = compression_quality;
// forcing UINT8 format
m_spec.set_format (TypeDesc::UINT8);
m_scanline_size = m_spec.width * m_spec.nchannels;
const int image_buffer = m_spec.height * m_scanline_size;
m_uncompressed_image.resize(image_buffer, 0);
return true;
}
// Encoder functions
PyObject* _anim_encoder_new(PyObject* self, PyObject* args)
{
int width, height;
uint32_t bgcolor;
int loop_count;
int minimize_size;
int kmin, kmax;
int allow_mixed;
int verbose;
WebPAnimEncoderOptions enc_options;
WebPAnimEncoderObject* encp = NULL;
WebPAnimEncoder* enc = NULL;
if (!PyArg_ParseTuple(args, "iiIiiiiii",
&width, &height, &bgcolor, &loop_count, &minimize_size,
&kmin, &kmax, &allow_mixed, &verbose)) {
return NULL;
}
// Setup and configure the encoder's options (these are animation-specific)
if (!WebPAnimEncoderOptionsInit(&enc_options)) {
PyErr_SetString(PyExc_RuntimeError, "failed to initialize encoder options");
return NULL;
}
enc_options.anim_params.bgcolor = bgcolor;
enc_options.anim_params.loop_count = loop_count;
enc_options.minimize_size = minimize_size;
enc_options.kmin = kmin;
enc_options.kmax = kmax;
enc_options.allow_mixed = allow_mixed;
enc_options.verbose = verbose;
// Validate canvas dimensions
if (width <= 0 || height <= 0) {
PyErr_SetString(PyExc_ValueError, "invalid canvas dimensions");
return NULL;
}
// Create a new animation encoder and picture frame
encp = PyObject_New(WebPAnimEncoderObject, &WebPAnimEncoder_Type);
if (encp) {
if (WebPPictureInit(&(encp->frame))) {
enc = WebPAnimEncoderNew(width, height, &enc_options);
if (enc) {
encp->enc = enc;
return (PyObject*) encp;
}
WebPPictureFree(&(encp->frame));
}
PyObject_Del(encp);
}
PyErr_SetString(PyExc_RuntimeError, "could not create encoder object");
return NULL;
}
static gboolean
export_webp (GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result,
GOutputStream *stream)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
WebPConfig config;
WebPPicture picture;
const Babl *format;
gint status;
g_return_val_if_fail (stream != NULL, FALSE);
if (!WebPConfigInit (&config) || !WebPPictureInit (&picture))
{
g_warning ("could not initialize WebP encoder");
return FALSE;
}
if (!WebPConfigPreset (&config, WEBP_PRESET_DEFAULT, o->quality))
{
g_warning("could not load WebP default preset");
return FALSE;
}
picture.width = result->width;
picture.height = result->height;
format = babl_format ("R'G'B'A u8");
if (!WebPValidateConfig (&config))
{
g_warning ("WebP encoder configuration is invalid");
return FALSE;
}
picture.writer = write_to_stream;
picture.custom_ptr = stream;
if (save_RGBA (&picture, input, result, format))
{
g_warning ("could not pass pixels data to WebP encoder");
return FALSE;
}
status = WebPEncode (&config, &picture);
WebPPictureFree (&picture);
return status ? TRUE : FALSE;
}
static int EncodeLossless(const uint8_t* const data, int width, int height,
int effort_level, // in [0..6] range
VP8BitWriter* const bw,
WebPAuxStats* const stats) {
int ok = 0;
WebPConfig config;
WebPPicture picture;
VP8LBitWriter tmp_bw;
WebPPictureInit(&picture);
picture.width = width;
picture.height = height;
picture.use_argb = 1;
picture.stats = stats;
if (!WebPPictureAlloc(&picture)) return 0;
// Transfer the alpha values to the green channel.
{
int i, j;
uint32_t* dst = picture.argb;
const uint8_t* src = data;
for (j = 0; j < picture.height; ++j) {
for (i = 0; i < picture.width; ++i) {
dst[i] = (src[i] << 8) | 0xff000000u;
}
src += width;
dst += picture.argb_stride;
}
}
WebPConfigInit(&config);
config.lossless = 1;
config.method = effort_level; // impact is very small
// Set moderate default quality setting for alpha. Higher qualities (80 and
// above) could be very slow.
config.quality = 10.f + 15.f * effort_level;
if (config.quality > 100.f) config.quality = 100.f;
ok = VP8LBitWriterInit(&tmp_bw, (width * height) >> 3);
ok = ok && (VP8LEncodeStream(&config, &picture, &tmp_bw) == VP8_ENC_OK);
WebPPictureFree(&picture);
if (ok) {
const uint8_t* const data = VP8LBitWriterFinish(&tmp_bw);
const size_t data_size = VP8LBitWriterNumBytes(&tmp_bw);
VP8BitWriterAppend(bw, data, data_size);
}
VP8LBitWriterDestroy(&tmp_bw);
return ok && !bw->error_;
}
static int EncodeLossless(const uint8_t* const data, int width, int height,
int effort_level, // in [0..6] range
VP8LBitWriter* const bw,
WebPAuxStats* const stats) {
int ok = 0;
WebPConfig config;
WebPPicture picture;
WebPPictureInit(&picture);
picture.width = width;
picture.height = height;
picture.use_argb = 1;
picture.stats = stats;
if (!WebPPictureAlloc(&picture)) return 0;
// Transfer the alpha values to the green channel.
{
int i, j;
uint32_t* dst = picture.argb;
const uint8_t* src = data;
for (j = 0; j < picture.height; ++j) {
for (i = 0; i < picture.width; ++i) {
dst[i] = src[i] << 8; // we leave A/R/B channels zero'd.
}
src += width;
dst += picture.argb_stride;
}
}
WebPConfigInit(&config);
config.lossless = 1;
config.method = effort_level; // impact is very small
// Set a low default quality for encoding alpha. Ensure that Alpha quality at
// lower methods (3 and below) is less than the threshold for triggering
// costly 'BackwardReferencesTraceBackwards'.
config.quality = 8.f * effort_level;
assert(config.quality >= 0 && config.quality <= 100.f);
ok = (VP8LEncodeStream(&config, &picture, bw) == VP8_ENC_OK);
WebPPictureFree(&picture);
ok = ok && !bw->error_;
if (!ok) {
VP8LBitWriterDestroy(bw);
return 0;
}
return 1;
}
static int EncodeLossless(const uint8_t* const data, int width, int height,
int effort_level, // in [0..6] range
VP8LBitWriter* const bw,
WebPAuxStats* const stats) {
int ok = 0;
WebPConfig config;
WebPPicture picture;
WebPPictureInit(&picture);
picture.width = width;
picture.height = height;
picture.use_argb = 1;
picture.stats = stats;
if (!WebPPictureAlloc(&picture)) return 0;
// Transfer the alpha values to the green channel.
WebPDispatchAlphaToGreen(data, width, picture.width, picture.height,
picture.argb, picture.argb_stride);
WebPConfigInit(&config);
config.lossless = 1;
// Enable exact, or it would alter RGB values of transparent alpha, which is
// normally OK but not here since we are not encoding the input image but an
// internal encoding-related image containing necessary exact information in
// RGB channels.
config.exact = 1;
config.method = effort_level; // impact is very small
// Set a low default quality for encoding alpha. Ensure that Alpha quality at
// lower methods (3 and below) is less than the threshold for triggering
// costly 'BackwardReferencesTraceBackwards'.
config.quality = 8.f * effort_level;
assert(config.quality >= 0 && config.quality <= 100.f);
// TODO(urvang): Temporary fix to avoid generating images that trigger
// a decoder bug related to alpha with color cache.
// See: https://code.google.com/p/webp/issues/detail?id=239
// Need to re-enable this later.
ok = (VP8LEncodeStream(&config, &picture, bw, 0 /*use_cache*/) == VP8_ENC_OK);
WebPPictureFree(&picture);
ok = ok && !bw->error_;
if (!ok) {
VP8LBitWriterWipeOut(bw);
return 0;
}
return 1;
}
void save_as_webp(T1& file,
T2 const& image,
WebPConfig const& config,
bool alpha)
{
bool valid = WebPValidateConfig(&config);
if (!valid)
{
throw std::runtime_error("Invalid configuration");
}
WebPPicture pic;
if (!WebPPictureInit(&pic))
{
throw std::runtime_error("version mismatch");
}
pic.width = image.width();
pic.height = image.height();
int ok = 0;
#if (WEBP_ENCODER_ABI_VERSION >> 8) >= 1
pic.use_argb = !!config.lossless;
// lossless fast track
if (pic.use_argb)
{
pic.colorspace = static_cast<WebPEncCSP>(pic.colorspace | WEBP_CSP_ALPHA_BIT);
if (WebPPictureAlloc(&pic)) {
ok = 1;
const int width = pic.width;
const int height = pic.height;
for (int y = 0; y < height; ++y) {
typename T2::pixel_type const * row = image.getRow(y);
for (int x = 0; x < width; ++x) {
const unsigned rgba = row[x];
unsigned a = (rgba >> 24) & 0xff;
unsigned r = rgba & 0xff;
unsigned g = (rgba >> 8 ) & 0xff;
unsigned b = (rgba >> 16) & 0xff;
const uint32_t argb = (a << 24) | (r << 16) | (g << 8) | (b);
pic.argb[x + y * pic.argb_stride] = argb;
}
}
}
int main(int argc, const char *argv[]) {
int verbose = 0;
int gif_error = GIF_ERROR;
WebPMuxError err = WEBP_MUX_OK;
int ok = 0;
const char *in_file = NULL, *out_file = NULL;
FILE* out = NULL;
GifFileType* gif = NULL;
int frame_duration = 0;
int frame_timestamp = 0;
GIFDisposeMethod orig_dispose = GIF_DISPOSE_NONE;
WebPPicture frame; // Frame rectangle only (not disposed).
WebPPicture curr_canvas; // Not disposed.
WebPPicture prev_canvas; // Disposed.
WebPPicture prev_to_prev_canvas; // Disposed.
WebPAnimEncoder* enc = NULL;
WebPAnimEncoderOptions enc_options;
WebPConfig config;
int is_first_frame = 1; // Whether we are processing the first frame.
int done;
int c;
int quiet = 0;
WebPData webp_data;
int keep_metadata = METADATA_XMP; // ICC not output by default.
WebPData icc_data;
int stored_icc = 0; // Whether we have already stored an ICC profile.
WebPData xmp_data;
int stored_xmp = 0; // Whether we have already stored an XMP profile.
int loop_count = 0;
int stored_loop_count = 0; // Whether we have found an explicit loop count.
WebPMux* mux = NULL;
int default_kmin = 1; // Whether to use default kmin value.
int default_kmax = 1;
if (!WebPConfigInit(&config) || !WebPAnimEncoderOptionsInit(&enc_options) ||
!WebPPictureInit(&frame) || !WebPPictureInit(&curr_canvas) ||
!WebPPictureInit(&prev_canvas) ||
!WebPPictureInit(&prev_to_prev_canvas)) {
fprintf(stderr, "Error! Version mismatch!\n");
return -1;
}
config.lossless = 1; // Use lossless compression by default.
WebPDataInit(&webp_data);
WebPDataInit(&icc_data);
WebPDataInit(&xmp_data);
if (argc == 1) {
Help();
return 0;
}
for (c = 1; c < argc; ++c) {
int parse_error = 0;
if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
Help();
return 0;
} else if (!strcmp(argv[c], "-o") && c < argc - 1) {
out_file = argv[++c];
} else if (!strcmp(argv[c], "-lossy")) {
config.lossless = 0;
} else if (!strcmp(argv[c], "-mixed")) {
enc_options.allow_mixed = 1;
config.lossless = 0;
} else if (!strcmp(argv[c], "-q") && c < argc - 1) {
config.quality = ExUtilGetFloat(argv[++c], &parse_error);
} else if (!strcmp(argv[c], "-m") && c < argc - 1) {
config.method = ExUtilGetInt(argv[++c], 0, &parse_error);
} else if (!strcmp(argv[c], "-min_size")) {
enc_options.minimize_size = 1;
} else if (!strcmp(argv[c], "-kmax") && c < argc - 1) {
enc_options.kmax = ExUtilGetInt(argv[++c], 0, &parse_error);
default_kmax = 0;
} else if (!strcmp(argv[c], "-kmin") && c < argc - 1) {
enc_options.kmin = ExUtilGetInt(argv[++c], 0, &parse_error);
default_kmin = 0;
} else if (!strcmp(argv[c], "-f") && c < argc - 1) {
config.filter_strength = ExUtilGetInt(argv[++c], 0, &parse_error);
} else if (!strcmp(argv[c], "-metadata") && c < argc - 1) {
static const struct {
const char* option;
int flag;
} kTokens[] = {
{ "all", METADATA_ALL },
{ "none", 0 },
{ "icc", METADATA_ICC },
{ "xmp", METADATA_XMP },
};
const size_t kNumTokens = sizeof(kTokens) / sizeof(*kTokens);
const char* start = argv[++c];
const char* const end = start + strlen(start);
keep_metadata = 0;
while (start < end) {
size_t i;
const char* token = strchr(start, ',');
if (token == NULL) token = end;
for (i = 0; i < kNumTokens; ++i) {
if ((size_t)(token - start) == strlen(kTokens[i].option) &&
!strncmp(start, kTokens[i].option, strlen(kTokens[i].option))) {
if (kTokens[i].flag != 0) {
keep_metadata |= kTokens[i].flag;
} else {
keep_metadata = 0;
}
break;
}
}
if (i == kNumTokens) {
fprintf(stderr, "Error! Unknown metadata type '%.*s'\n",
(int)(token - start), start);
Help();
return -1;
}
start = token + 1;
}
} else if (!strcmp(argv[c], "-mt")) {
++config.thread_level;
} else if (!strcmp(argv[c], "-version")) {
const int enc_version = WebPGetEncoderVersion();
const int mux_version = WebPGetMuxVersion();
printf("WebP Encoder version: %d.%d.%d\nWebP Mux version: %d.%d.%d\n",
(enc_version >> 16) & 0xff, (enc_version >> 8) & 0xff,
enc_version & 0xff, (mux_version >> 16) & 0xff,
(mux_version >> 8) & 0xff, mux_version & 0xff);
return 0;
} else if (!strcmp(argv[c], "-quiet")) {
quiet = 1;
} else if (!strcmp(argv[c], "-v")) {
verbose = 1;
enc_options.verbose = 1;
} else if (!strcmp(argv[c], "--")) {
if (c < argc - 1) in_file = argv[++c];
break;
} else if (argv[c][0] == '-') {
fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
Help();
return -1;
} else {
in_file = argv[c];
}
if (parse_error) {
Help();
return -1;
}
}
int main(int argc, const char *argv[]) {
int verbose = 0;
int gif_error = GIF_ERROR;
WebPMuxError err = WEBP_MUX_OK;
int ok = 0;
const char *in_file = NULL, *out_file = NULL;
FILE* out = NULL;
GifFileType* gif = NULL;
WebPPicture picture;
WebPPicture view;
WebPMemoryWriter memory;
WebPMuxFrameInfo frame;
WebPMuxAnimParams anim = { WHITE_COLOR, 0 };
int is_first_frame = 1;
int done;
int c;
int quiet = 0;
WebPConfig config;
WebPMux* mux = NULL;
WebPData webp_data = { NULL, 0 };
int stored_icc = 0; // Whether we have already stored an ICC profile.
int stored_xmp = 0;
memset(&frame, 0, sizeof(frame));
frame.id = WEBP_CHUNK_ANMF;
frame.dispose_method = WEBP_MUX_DISPOSE_BACKGROUND;
if (!WebPConfigInit(&config) || !WebPPictureInit(&picture)) {
fprintf(stderr, "Error! Version mismatch!\n");
return -1;
}
config.lossless = 1; // Use lossless compression by default.
if (argc == 1) {
Help();
return 0;
}
for (c = 1; c < argc; ++c) {
if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
Help();
return 0;
} else if (!strcmp(argv[c], "-o") && c < argc - 1) {
out_file = argv[++c];
} else if (!strcmp(argv[c], "-lossy")) {
config.lossless = 0;
} else if (!strcmp(argv[c], "-q") && c < argc - 1) {
config.quality = (float)strtod(argv[++c], NULL);
} else if (!strcmp(argv[c], "-m") && c < argc - 1) {
config.method = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-f") && c < argc - 1) {
config.filter_strength = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-version")) {
const int enc_version = WebPGetEncoderVersion();
const int mux_version = WebPGetMuxVersion();
printf("WebP Encoder version: %d.%d.%d\nWebP Mux version: %d.%d.%d\n",
(enc_version >> 16) & 0xff, (enc_version >> 8) & 0xff,
enc_version & 0xff, (mux_version >> 16) & 0xff,
(mux_version >> 8) & 0xff, mux_version & 0xff);
return 0;
} else if (!strcmp(argv[c], "-quiet")) {
quiet = 1;
} else if (!strcmp(argv[c], "-v")) {
verbose = 1;
} else if (argv[c][0] == '-') {
fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
Help();
return -1;
} else {
in_file = argv[c];
}
}
/**
Encode a FIBITMAP to a WebP image
@param hmem Memory output stream, containing on return the encoded image
@param dib The FIBITMAP to encode
@param flags FreeImage save flags
@return Returns TRUE if successfull, returns FALSE otherwise
*/
static BOOL
EncodeImage(FIMEMORY *hmem, FIBITMAP *dib, int flags) {
WebPPicture picture; // Input buffer
WebPConfig config; // Coding parameters
BOOL bIsFlipped = FALSE;
try {
const unsigned width = FreeImage_GetWidth(dib);
const unsigned height = FreeImage_GetHeight(dib);
const unsigned bpp = FreeImage_GetBPP(dib);
const unsigned pitch = FreeImage_GetPitch(dib);
// check image type
FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
if( !((image_type == FIT_BITMAP) && ((bpp == 24) || (bpp == 32))) ) {
throw FI_MSG_ERROR_UNSUPPORTED_FORMAT;
}
// check format limits
if(MAX(width, height) > WEBP_MAX_DIMENSION) {
FreeImage_OutputMessageProc(s_format_id, "Unsupported image size: width x height = %d x %d", width, height);
return FALSE;
}
// Initialize output I/O
if(WebPPictureInit(&picture) == 1) {
picture.writer = WebP_MemoryWriter;
picture.custom_ptr = hmem;
picture.width = (int)width;
picture.height = (int)height;
} else {
throw "Couldn't initialize WebPPicture";
}
// --- Set encoding parameters ---
// Initialize encoding parameters to default values
WebPConfigInit(&config);
// quality/speed trade-off (0=fast, 6=slower-better)
config.method = 6;
if((flags & WEBP_LOSSLESS) == WEBP_LOSSLESS) {
// lossless encoding
config.lossless = 1;
picture.use_argb = 1;
} else if((flags & 0x7F) > 0) {
// lossy encoding
config.lossless = 0;
// quality is between 1 (smallest file) and 100 (biggest) - default to 75
config.quality = (float)(flags & 0x7F);
if(config.quality > 100) {
config.quality = 100;
}
}
// validate encoding parameters
if(WebPValidateConfig(&config) == 0) {
throw "Failed to initialize encoder";
}
// --- Perform encoding ---
// Invert dib scanlines
bIsFlipped = FreeImage_FlipVertical(dib);
// convert dib buffer to output stream
const BYTE *bits = FreeImage_GetBits(dib);
#if FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
switch(bpp) {
case 24:
WebPPictureImportBGR(&picture, bits, pitch);
break;
case 32:
WebPPictureImportBGRA(&picture, bits, pitch);
break;
}
#else
switch(bpp) {
case 24:
WebPPictureImportRGB(&picture, bits, pitch);
break;
case 32:
WebPPictureImportRGBA(&picture, bits, pitch);
break;
}
#endif // FREEIMAGE_COLORORDER == FREEIMAGE_COLORORDER_BGR
if(!WebPEncode(&config, &picture)) {
throw "Failed to encode image";
}
WebPPictureFree(&picture);
if(bIsFlipped) {
// invert dib scanlines
FreeImage_FlipVertical(dib);
}
return TRUE;
} catch (const char* text) {
WebPPictureFree(&picture);
if(bIsFlipped) {
// invert dib scanlines
FreeImage_FlipVertical(dib);
}
if(NULL != text) {
FreeImage_OutputMessageProc(s_format_id, text);
}
}
return FALSE;
}
bool QWebpHandler::write(const QImage &image)
{
if (image.isNull()) {
qWarning() << "source image is null.";
return false;
}
QImage srcImage = image;
#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
if (srcImage.format() != QImage::Format_ARGB32)
srcImage = srcImage.convertToFormat(QImage::Format_ARGB32);
#else /* Q_BIG_ENDIAN */
if (srcImage.format() != QImage::Format_RGBA8888)
srcImage = srcImage.convertToFormat(QImage::Format_RGBA8888);
#endif
WebPPicture picture;
WebPConfig config;
if (!WebPPictureInit(&picture) || !WebPConfigInit(&config)) {
qWarning() << "failed to init webp picture and config";
return false;
}
picture.width = srcImage.width();
picture.height = srcImage.height();
picture.use_argb = 1;
#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
if (!WebPPictureImportBGRA(&picture, srcImage.bits(), srcImage.bytesPerLine())) {
#else /* Q_BIG_ENDIAN */
if (!WebPPictureImportRGBA(&picture, srcImage.bits(), srcImage.bytesPerLine())) {
#endif
qWarning() << "failed to import image data to webp picture.";
WebPPictureFree(&picture);
return false;
}
config.lossless = m_lossless;
config.quality = m_quality;
picture.writer = pictureWriter;
picture.custom_ptr = device();
if (!WebPEncode(&config, &picture)) {
qWarning() << "failed to encode webp picture, error code: " << picture.error_code;
WebPPictureFree(&picture);
return false;
}
WebPPictureFree(&picture);
return true;
}
QVariant QWebpHandler::option(ImageOption option) const
{
if (!supportsOption(option) || !ensureScanned())
return QVariant();
switch (option) {
case Quality:
return m_quality;
case Size:
return QSize(m_width, m_height);
case Animation:
return (m_flags & ANIMATION_FLAG) == ANIMATION_FLAG;
default:
return QVariant();
}
}
void QWebpHandler::setOption(ImageOption option, const QVariant &value)
{
switch (option) {
case Quality:
m_quality = qBound(0, value.toInt(), 100);
m_lossless = (m_quality >= 100);
return;
default:
break;
}
return QImageIOHandler::setOption(option, value);
}
bool QWebpHandler::supportsOption(ImageOption option) const
{
return option == Quality
|| option == Size
|| option == Animation;
}
QByteArray QWebpHandler::name() const
{
return QByteArrayLiteral("webp");
}
int QWebpHandler::imageCount() const
{
if (!ensureScanned())
return 0;
if ((m_flags & ANIMATION_FLAG) == 0)
return 1;
return m_frameCount;
}
int QWebpHandler::currentImageNumber() const
{
if (!ensureScanned())
return 0;
return m_iter.frame_num;
}
QRect QWebpHandler::currentImageRect() const
{
if (!ensureScanned())
return QRect();
return QRect(m_iter.x_offset, m_iter.y_offset, m_iter.width, m_iter.height);
}
bool QWebpHandler::jumpToImage(int imageNumber)
{
if (!ensureScanned())
return false;
WebPDemuxReleaseIterator(&m_iter);
return WebPDemuxGetFrame(m_demuxer, imageNumber, &m_iter);
}
bool QWebpHandler::jumpToNextImage()
{
if (!ensureScanned())
return false;
return WebPDemuxNextFrame(&m_iter);
}
int QWebpHandler::loopCount() const
{
if (!ensureScanned() || (m_flags & ANIMATION_FLAG) == 0)
return 0;
return m_loop;
}
int QWebpHandler::nextImageDelay() const
{
if (!ensureScanned())
return 0;
return m_iter.duration;
}
int
encodeWEBP(Vbitmap *vbitmap, Ychannel *channelout, YmagineFormatOptions *options)
{
int rc = YMAGINE_ERROR;
#if HAVE_WEBP
WebPConfig config;
WebPPicture picture;
WebPPreset preset = WEBP_PRESET_PHOTO; // One of DEFAULT, PICTURE, PHOTO, DRAWING, ICON or TEXT
int width;
int height;
int pitch;
int quality;
const unsigned char *pixels;
int colormode;
/*
* List of encoding options for WebP config
* int lossless; // Lossless encoding (0=lossy(default), 1=lossless).
* float quality; // between 0 (smallest file) and 100 (biggest)
* int method; // quality/speed trade-off (0=fast, 6=slower-better)
*
* WebPImageHint image_hint; // Hint for image type (lossless only for now).
*
* // Parameters related to lossy compression only:
* int target_size; // if non-zero, set the desired target size in bytes.
* // Takes precedence over the 'compression' parameter.
* float target_PSNR; // if non-zero, specifies the minimal distortion to
* // try to achieve. Takes precedence over target_size.
* int segments; // maximum number of segments to use, in [1..4]
* int sns_strength; // Spatial Noise Shaping. 0=off, 100=maximum.
* int filter_strength; // range: [0 = off .. 100 = strongest]
* int filter_sharpness; // range: [0 = off .. 7 = least sharp]
* int filter_type; // filtering type: 0 = simple, 1 = strong (only used
* // if filter_strength > 0 or autofilter > 0)
* int autofilter; // Auto adjust filter's strength [0 = off, 1 = on]
* int alpha_compression; // Algorithm for encoding the alpha plane (0 = none,
* // 1 = compressed with WebP lossless). Default is 1.
* int alpha_filtering; // Predictive filtering method for alpha plane.
* // 0: none, 1: fast, 2: best. Default if 1.
* int alpha_quality; // Between 0 (smallest size) and 100 (lossless).
* // Default is 100.
* int pass; // number of entropy-analysis passes (in [1..10]).
*
* int show_compressed; // if true, export the compressed picture back.
* // In-loop filtering is not applied.
* int preprocessing; // preprocessing filter (0=none, 1=segment-smooth)
* int partitions; // log2(number of token partitions) in [0..3]
* // Default is set to 0 for easier progressive decoding.
* int partition_limit; // quality degradation allowed to fit the 512k limit on
* // prediction modes coding (0: no degradation,
* // 100: maximum possible degradation).
*/
colormode = VbitmapColormode(vbitmap);
if (colormode != VBITMAP_COLOR_RGBA && colormode != VBITMAP_COLOR_RGB) {
ALOGD("currently only support RGB, RGBA webp encoding");
return rc;
}
quality = YmagineFormatOptions_normalizeQuality(options);
if (!WebPConfigPreset(&config, preset, (float) quality)) {
return YMAGINE_ERROR; // version error
}
if (options && options->accuracy >= 0) {
int method = options->accuracy / 15;
if (method > 6) {
method = 6;
}
config.method = method;
}
if (!WebPValidateConfig(&config)) {
// parameter ranges verification failed
return YMAGINE_ERROR;
}
rc = VbitmapLock(vbitmap);
if (rc < 0) {
ALOGE("AndroidBitmap_lockPixels() failed");
return YMAGINE_ERROR;
}
width = VbitmapWidth(vbitmap);
height = VbitmapHeight(vbitmap);
pitch = VbitmapPitch(vbitmap);
pixels = VbitmapBuffer(vbitmap);
if (WebPPictureInit(&picture)) {
picture.use_argb = 1;
picture.width = width;
picture.height = height;
picture.writer = WebPYchannelWrite;
picture.custom_ptr = channelout;
if (colormode == VBITMAP_COLOR_RGBA) {
WebPPictureImportRGBA(&picture, pixels, pitch);
} else {
WebPPictureImportRGB(&picture, pixels, pitch);
}
WebPEncode(&config, &picture);
WebPPictureFree(&picture);
}
VbitmapUnlock(vbitmap);
rc = YMAGINE_OK;
#endif
return rc;
}
/**
* Convert bitmap object from Android code to WebP format. Save to file.
*/
jint Java_com_tbliss_android_seniorproject_webpconv_WebPConv_doConvJniGraphics2( JNIEnv* env,
jobject javaThis,
jobject jbitmap,
jfloat jqualityFactor,
jstring filename)
{
int ret = 0;
float cqualityFactor;
int stride, width, height;
void* pixels; // pointer to address of bitmap
int outputSize = 0;
AndroidBitmapInfo bitmapInfo;
uint8_t* outputPointer;
uint8_t* cbitmapPointer;
WebPConfig config;
WebPMemoryWriter wrt;
size_t dataWritten = 0;
int bytesWritten = 0;
FILE* fileout = NULL;
const char* fname = (*env)->GetStringUTFChars(env, filename, NULL);
// Get Bitmap info (height/width/stride)
if ((ret = AndroidBitmap_getInfo(env, jbitmap, &bitmapInfo)) < 0){
LOGV("Could not get Bitmap info. error=%d", ret);
return 0;
}
width = (int)bitmapInfo.width;
height = (int)bitmapInfo.height;
stride = (int)bitmapInfo.stride; // width * 4
LOGV("Bitmap: width=%d, height=%d, stride=%d, format=%d", width, height, stride, bitmapInfo.format);
// Lock Bitmap pixels
if ((ret = AndroidBitmap_lockPixels(env, jbitmap, &pixels)) < 0) {
LOGV("AndroidBitmap_lockPixels() failed ! error=%d", ret);
return 0;
}
cbitmapPointer = (uint8_t*)pixels;
outputSize = stride * height;
LOGV("output_size: %d", outputSize);
outputPointer = (uint8_t*) malloc(outputSize);
cqualityFactor = (float)jqualityFactor;
// Setup a config
if (!WebPConfigPreset(&config, WEBP_PRESET_PICTURE, cqualityFactor)) {
LOGV("WebPConfigPreset failed");
return 0; // version error
}
// ... additional tuning
config.method = 1;
LOGV("config.method = %d", config.method);
if (WebPValidateConfig(&config) != 1) {
LOGV("Error with config");
}
// Setup the input data
WebPPicture pic;
if (!WebPPictureInit(&pic)) {
LOGV("WebPPictureInit failed");
return 0; // version error
}
pic.width = width;
pic.height = height;
if (!WebPPictureImportRGBA(&pic, cbitmapPointer, stride)) {
LOGV("WebPPictureImportRGB failed");
return 0;
}
// Set up a byte-output write method. WebPMemoryWriter, for instance.
pic.writer = MyMemoryWriter;
pic.custom_ptr = &wrt;
//InitMemoryWriter(&wrt);
wrt.mem = &outputPointer;
wrt.size = &dataWritten;
wrt.max_size = outputSize;
// Compress!
ret = WebPEncode(&config, &pic); // ok = 0 => error occurred!
if (!ret) {
LOGV("ret == 0, WebPEncode fail");
}
WebPPictureFree(&pic); // must be called independently of the 'ok' result.
// Write to phone
fileout = fopen(fname, "wb");
if(!fileout){
LOGV("cannot open output file %s", fname);
return 0;
}
bytesWritten = fwrite(outputPointer, 1, dataWritten, fileout);
LOGV("bytesWritten: %d", bytesWritten);
// Unlock pixels of Bitmap
fclose(fileout);
AndroidBitmap_unlockPixels(env, jbitmap);
free(outputPointer);
(*env)->ReleaseStringUTFChars(env, filename, fname);
return dataWritten;
}
WebPAnimEncoder* WebPAnimEncoderNewInternal(
int width, int height, const WebPAnimEncoderOptions* enc_options,
int abi_version) {
WebPAnimEncoder* enc;
if (WEBP_ABI_IS_INCOMPATIBLE(abi_version, WEBP_MUX_ABI_VERSION)) {
return NULL;
}
if (width <= 0 || height <= 0 ||
(width * (uint64_t)height) >= MAX_IMAGE_AREA) {
return NULL;
}
enc = (WebPAnimEncoder*)WebPSafeCalloc(1, sizeof(*enc));
if (enc == NULL) return NULL;
// sanity inits, so we can call WebPAnimEncoderDelete():
enc->encoded_frames_ = NULL;
enc->mux_ = NULL;
// Dimensions and options.
*(int*)&enc->canvas_width_ = width;
*(int*)&enc->canvas_height_ = height;
if (enc_options != NULL) {
*(WebPAnimEncoderOptions*)&enc->options_ = *enc_options;
SanitizeEncoderOptions((WebPAnimEncoderOptions*)&enc->options_);
} else {
DefaultEncoderOptions((WebPAnimEncoderOptions*)&enc->options_);
}
// Canvas buffers.
if (!WebPPictureInit(&enc->curr_canvas_copy_) ||
!WebPPictureInit(&enc->prev_canvas_) ||
!WebPPictureInit(&enc->prev_canvas_disposed_)) {
return NULL;
}
enc->curr_canvas_copy_.width = width;
enc->curr_canvas_copy_.height = height;
enc->curr_canvas_copy_.use_argb = 1;
if (!WebPPictureAlloc(&enc->curr_canvas_copy_) ||
!WebPPictureCopy(&enc->curr_canvas_copy_, &enc->prev_canvas_) ||
!WebPPictureCopy(&enc->curr_canvas_copy_, &enc->prev_canvas_disposed_)) {
goto Err;
}
WebPUtilClearPic(&enc->prev_canvas_, NULL);
enc->curr_canvas_copy_modified_ = 1;
// Encoded frames.
ResetCounters(enc);
// Note: one extra storage is for the previous frame.
enc->size_ = enc->options_.kmax - enc->options_.kmin + 1;
// We need space for at least 2 frames. But when kmin, kmax are both zero,
// enc->size_ will be 1. So we handle that special case below.
if (enc->size_ < 2) enc->size_ = 2;
enc->encoded_frames_ =
(EncodedFrame*)WebPSafeCalloc(enc->size_, sizeof(*enc->encoded_frames_));
if (enc->encoded_frames_ == NULL) goto Err;
enc->mux_ = WebPMuxNew();
if (enc->mux_ == NULL) goto Err;
enc->count_since_key_frame_ = 0;
enc->first_timestamp_ = 0;
enc->prev_timestamp_ = 0;
enc->prev_candidate_undecided_ = 0;
enc->is_first_frame_ = 1;
enc->got_null_frame_ = 0;
return enc; // All OK.
Err:
WebPAnimEncoderDelete(enc);
return NULL;
}
int main(int argc, const char *argv[]) {
WebPPicture pic1, pic2;
int ret = 1;
float disto[5];
size_t size1 = 0, size2 = 0;
int type = 0;
int c;
int help = 0;
int keep_alpha = 0;
int scale = 0;
int use_gray = 0;
const char* name1 = NULL;
const char* name2 = NULL;
const char* output = NULL;
if (!WebPPictureInit(&pic1) || !WebPPictureInit(&pic2)) {
fprintf(stderr, "Can't init pictures\n");
return 1;
}
for (c = 1; c < argc; ++c) {
if (!strcmp(argv[c], "-ssim")) {
type = 1;
} else if (!strcmp(argv[c], "-psnr")) {
type = 0;
} else if (!strcmp(argv[c], "-alpha")) {
keep_alpha = 1;
} else if (!strcmp(argv[c], "-scale")) {
scale = 1;
} else if (!strcmp(argv[c], "-gray")) {
use_gray = 1;
} else if (!strcmp(argv[c], "-h")) {
help = 1;
ret = 0;
} else if (!strcmp(argv[c], "-o")) {
if (++c == argc) {
fprintf(stderr, "missing file name after %s option.\n", argv[c - 1]);
goto End;
}
output = argv[c];
} else if (name1 == NULL) {
name1 = argv[c];
} else {
name2 = argv[c];
}
}
if (help || name1 == NULL || name2 == NULL) {
if (!help) {
fprintf(stderr, "Error: missing arguments.\n");
}
Help();
goto End;
}
if ((size1 = ReadPicture(name1, &pic1, 1)) == 0) {
goto End;
}
if ((size2 = ReadPicture(name2, &pic2, 1)) == 0) {
goto End;
}
if (!keep_alpha) {
WebPBlendAlpha(&pic1, 0x00000000);
WebPBlendAlpha(&pic2, 0x00000000);
}
if (!WebPPictureDistortion(&pic1, &pic2, type, disto)) {
fprintf(stderr, "Error while computing the distortion.\n");
goto End;
}
printf("%u %.2f %.2f %.2f %.2f %.2f\n",
(unsigned int)size1, disto[4],
disto[0], disto[1], disto[2], disto[3]);
if (output != NULL) {
uint8_t* data = NULL;
size_t data_size = 0;
if (pic1.use_argb != pic2.use_argb) {
fprintf(stderr, "Pictures are not in the same argb format. "
"Can't save the difference map.\n");
goto End;
}
if (pic1.use_argb) {
int n;
fprintf(stderr, "max differences per channel: ");
for (n = 0; n < 3; ++n) { // skip the alpha channel
const int range = (type == 1) ?
SSIMScaleChannel((uint8_t*)pic1.argb + n, pic1.argb_stride * 4,
(const uint8_t*)pic2.argb + n, pic2.argb_stride * 4,
4, pic1.width, pic1.height, scale) :
DiffScaleChannel((uint8_t*)pic1.argb + n, pic1.argb_stride * 4,
(const uint8_t*)pic2.argb + n, pic2.argb_stride * 4,
4, pic1.width, pic1.height, scale);
if (range < 0) fprintf(stderr, "\nError computing diff map\n");
fprintf(stderr, "[%d]", range);
}
fprintf(stderr, "\n");
if (use_gray) ConvertToGray(&pic1);
} else {
fprintf(stderr, "Can only compute the difference map in ARGB format.\n");
goto End;
}
data_size = WebPEncodeLosslessBGRA((const uint8_t*)pic1.argb,
pic1.width, pic1.height,
pic1.argb_stride * 4,
&data);
if (data_size == 0) {
fprintf(stderr, "Error during lossless encoding.\n");
goto End;
}
ret = ImgIoUtilWriteFile(output, data, data_size) ? 0 : 1;
WebPFree(data);
if (ret) goto End;
}
ret = 0;
End:
WebPPictureFree(&pic1);
WebPPictureFree(&pic2);
return ret;
}
int main(int argc, const char *argv[]) {
int verbose = 0;
int gif_error = GIF_ERROR;
WebPMuxError err = WEBP_MUX_OK;
int ok = 0;
const char *in_file = NULL, *out_file = NULL;
FILE* out = NULL;
GifFileType* gif = NULL;
WebPConfig config;
WebPPicture frame;
WebPMuxFrameInfo info;
WebPMuxAnimParams anim = { WHITE_COLOR, 0 };
WebPFrameCache* cache = NULL;
int is_first_frame = 1; // Whether we are processing the first frame.
int done;
int c;
int quiet = 0;
WebPMux* mux = NULL;
WebPData webp_data = { NULL, 0 };
int keep_metadata = METADATA_XMP; // ICC not output by default.
int stored_icc = 0; // Whether we have already stored an ICC profile.
int stored_xmp = 0;
int default_kmin = 1; // Whether to use default kmin value.
int default_kmax = 1;
size_t kmin = 0;
size_t kmax = 0;
int allow_mixed = 0; // If true, each frame can be lossy or lossless.
ResetFrameInfo(&info);
if (!WebPConfigInit(&config) || !WebPPictureInit(&frame)) {
fprintf(stderr, "Error! Version mismatch!\n");
return -1;
}
config.lossless = 1; // Use lossless compression by default.
config.image_hint = WEBP_HINT_GRAPH; // always low-color
if (argc == 1) {
Help();
return 0;
}
for (c = 1; c < argc; ++c) {
int parse_error = 0;
if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
Help();
return 0;
} else if (!strcmp(argv[c], "-o") && c < argc - 1) {
out_file = argv[++c];
} else if (!strcmp(argv[c], "-lossy")) {
config.lossless = 0;
} else if (!strcmp(argv[c], "-mixed")) {
allow_mixed = 1;
config.lossless = 0;
} else if (!strcmp(argv[c], "-q") && c < argc - 1) {
config.quality = ExUtilGetFloat(argv[++c], &parse_error);
} else if (!strcmp(argv[c], "-m") && c < argc - 1) {
config.method = ExUtilGetInt(argv[++c], 0, &parse_error);
} else if (!strcmp(argv[c], "-kmax") && c < argc - 1) {
kmax = ExUtilGetUInt(argv[++c], 0, &parse_error);
default_kmax = 0;
} else if (!strcmp(argv[c], "-kmin") && c < argc - 1) {
kmin = ExUtilGetUInt(argv[++c], 0, &parse_error);
default_kmin = 0;
} else if (!strcmp(argv[c], "-f") && c < argc - 1) {
config.filter_strength = ExUtilGetInt(argv[++c], 0, &parse_error);
} else if (!strcmp(argv[c], "-metadata") && c < argc - 1) {
static const struct {
const char* option;
int flag;
} kTokens[] = {
{ "all", METADATA_ALL },
{ "none", 0 },
{ "icc", METADATA_ICC },
{ "xmp", METADATA_XMP },
};
const size_t kNumTokens = sizeof(kTokens) / sizeof(*kTokens);
const char* start = argv[++c];
const char* const end = start + strlen(start);
keep_metadata = 0;
while (start < end) {
size_t i;
const char* token = strchr(start, ',');
if (token == NULL) token = end;
for (i = 0; i < kNumTokens; ++i) {
if ((size_t)(token - start) == strlen(kTokens[i].option) &&
!strncmp(start, kTokens[i].option, strlen(kTokens[i].option))) {
if (kTokens[i].flag != 0) {
keep_metadata |= kTokens[i].flag;
} else {
keep_metadata = 0;
}
break;
}
}
if (i == kNumTokens) {
fprintf(stderr, "Error! Unknown metadata type '%.*s'\n",
(int)(token - start), start);
Help();
return -1;
}
start = token + 1;
}
} else if (!strcmp(argv[c], "-mt")) {
++config.thread_level;
} else if (!strcmp(argv[c], "-version")) {
const int enc_version = WebPGetEncoderVersion();
const int mux_version = WebPGetMuxVersion();
printf("WebP Encoder version: %d.%d.%d\nWebP Mux version: %d.%d.%d\n",
(enc_version >> 16) & 0xff, (enc_version >> 8) & 0xff,
enc_version & 0xff, (mux_version >> 16) & 0xff,
(mux_version >> 8) & 0xff, mux_version & 0xff);
return 0;
} else if (!strcmp(argv[c], "-quiet")) {
quiet = 1;
} else if (!strcmp(argv[c], "-v")) {
verbose = 1;
} else if (!strcmp(argv[c], "--")) {
if (c < argc - 1) in_file = argv[++c];
break;
} else if (argv[c][0] == '-') {
fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
Help();
return -1;
} else {
in_file = argv[c];
}
if (parse_error) {
Help();
return -1;
}
}
int main(int argc, const char *argv[]) {
const char *in_file = NULL, *out_file = NULL, *dump_file = NULL;
FILE *out = NULL;
int c;
int short_output = 0;
int quiet = 0;
int keep_alpha = 0;
int crop = 0, crop_x = 0, crop_y = 0, crop_w = 0, crop_h = 0;
int resize_w = 0, resize_h = 0;
WebPPicture picture;
WebPConfig config;
WebPAuxStats stats;
Stopwatch stop_watch;
#ifdef WEBP_EXPERIMENTAL_FEATURES
keep_alpha = 1;
#endif
if (!WebPPictureInit(&picture) || !WebPConfigInit(&config)) {
fprintf(stderr, "Error! Version mismatch!\n");
goto Error;
}
if (argc == 1) {
HelpShort();
return 0;
}
for (c = 1; c < argc; ++c) {
if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
HelpShort();
return 0;
} else if (!strcmp(argv[c], "-H") || !strcmp(argv[c], "-longhelp")) {
HelpLong();
return 0;
} else if (!strcmp(argv[c], "-o") && c < argc - 1) {
out_file = argv[++c];
} else if (!strcmp(argv[c], "-d") && c < argc - 1) {
dump_file = argv[++c];
config.show_compressed = 1;
} else if (!strcmp(argv[c], "-short")) {
short_output++;
} else if (!strcmp(argv[c], "-s") && c < argc - 2) {
picture.width = strtol(argv[++c], NULL, 0);
picture.height = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-m") && c < argc - 1) {
config.method = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-q") && c < argc - 1) {
config.quality = (float)strtod(argv[++c], NULL);
} else if (!strcmp(argv[c], "-size") && c < argc - 1) {
config.target_size = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-psnr") && c < argc - 1) {
config.target_PSNR = (float)strtod(argv[++c], NULL);
} else if (!strcmp(argv[c], "-sns") && c < argc - 1) {
config.sns_strength = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-f") && c < argc - 1) {
config.filter_strength = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-af")) {
config.autofilter = 1;
} else if (!strcmp(argv[c], "-strong")) {
config.filter_type = 1;
} else if (!strcmp(argv[c], "-sharpness") && c < argc - 1) {
config.filter_sharpness = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-pass") && c < argc - 1) {
config.pass = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-pre") && c < argc - 1) {
config.preprocessing = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-segments") && c < argc - 1) {
config.segments = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-partition_limit") && c < argc - 1) {
config.partition_limit = strtol(argv[++c], NULL, 0);
#ifdef WEBP_EXPERIMENTAL_FEATURES
} else if (!strcmp(argv[c], "-alpha_comp") && c < argc - 1) {
config.alpha_compression = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-noalpha")) {
keep_alpha = 0;
#endif
} else if (!strcmp(argv[c], "-map") && c < argc - 1) {
picture.extra_info_type = strtol(argv[++c], NULL, 0);
#ifdef WEBP_EXPERIMENTAL_FEATURES
} else if (!strcmp(argv[c], "-444")) {
picture.colorspace = WEBP_YUV444;
} else if (!strcmp(argv[c], "-422")) {
picture.colorspace = WEBP_YUV422;
} else if (!strcmp(argv[c], "-gray")) {
picture.colorspace = WEBP_YUV400;
#endif
} else if (!strcmp(argv[c], "-crop") && c < argc - 4) {
crop = 1;
crop_x = strtol(argv[++c], NULL, 0);
crop_y = strtol(argv[++c], NULL, 0);
crop_w = strtol(argv[++c], NULL, 0);
crop_h = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-resize") && c < argc - 2) {
resize_w = strtol(argv[++c], NULL, 0);
resize_h = strtol(argv[++c], NULL, 0);
#ifndef WEBP_DLL
} else if (!strcmp(argv[c], "-noasm")) {
VP8GetCPUInfo = NULL;
#endif
} else if (!strcmp(argv[c], "-version")) {
const int version = WebPGetEncoderVersion();
printf("%d.%d.%d\n",
(version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff);
return 0;
} else if (!strcmp(argv[c], "-quiet")) {
quiet = 1;
} else if (!strcmp(argv[c], "-preset") && c < argc - 1) {
WebPPreset preset;
++c;
if (!strcmp(argv[c], "default")) {
preset = WEBP_PRESET_DEFAULT;
} else if (!strcmp(argv[c], "photo")) {
preset = WEBP_PRESET_PHOTO;
} else if (!strcmp(argv[c], "picture")) {
preset = WEBP_PRESET_PICTURE;
} else if (!strcmp(argv[c], "drawing")) {
preset = WEBP_PRESET_DRAWING;
} else if (!strcmp(argv[c], "icon")) {
preset = WEBP_PRESET_ICON;
} else if (!strcmp(argv[c], "text")) {
preset = WEBP_PRESET_TEXT;
} else {
fprintf(stderr, "Error! Unrecognized preset: %s\n", argv[c]);
goto Error;
}
if (!WebPConfigPreset(&config, preset, config.quality)) {
fprintf(stderr, "Error! Could initialize configuration with preset.\n");
goto Error;
}
} else if (!strcmp(argv[c], "-v")) {
verbose = 1;
} else if (argv[c][0] == '-') {
fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
HelpLong();
return -1;
} else {
in_file = argv[c];
}
}
void save_as_webp(T1& file,
float quality,
int method,
int lossless,
int image_hint,
bool alpha,
T2 const& image)
{
WebPConfig config;
if (!WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, quality))
{
throw std::runtime_error("version mismatch");
}
// Add additional tuning
if (method >= 0) config.method = method;
#if (WEBP_ENCODER_ABI_VERSION >> 8) >= 1
config.lossless = !!lossless;
config.image_hint = static_cast<WebPImageHint>(image_hint);
#else
#ifdef _MSC_VER
#pragma NOTE(compiling against webp that does not support lossless flag)
#else
#warning "compiling against webp that does not support lossless flag"
#endif
#endif
bool valid = WebPValidateConfig(&config);
if (!valid)
{
throw std::runtime_error("Invalid configuration");
}
WebPPicture pic;
if (!WebPPictureInit(&pic))
{
throw std::runtime_error("version mismatch");
}
pic.width = image.width();
pic.height = image.height();
int ok = 0;
#if (WEBP_ENCODER_ABI_VERSION >> 8) >= 1
pic.use_argb = !!lossless;
// lossless fast track
if (pic.use_argb)
{
pic.colorspace = static_cast<WebPEncCSP>(pic.colorspace | WEBP_CSP_ALPHA_BIT);
if (WebPPictureAlloc(&pic)) {
ok = 1;
const int width = pic.width;
const int height = pic.height;
for (int y = 0; y < height; ++y) {
typename T2::pixel_type const * row = image.getRow(y);
for (int x = 0; x < width; ++x) {
const unsigned rgba = row[x];
unsigned a = (rgba >> 24) & 0xff;
unsigned r = rgba & 0xff;
unsigned g = (rgba >> 8 ) & 0xff;
unsigned b = (rgba >> 16) & 0xff;
const uint32_t argb = (a << 24) | (r << 16) | (g << 8) | (b);
pic.argb[x + y * pic.argb_stride] = argb;
}
}
}
static MagickBooleanType WriteWEBPImage(const ImageInfo *image_info,
Image *image)
{
int
webp_status;
MagickBooleanType
status;
register const PixelPacket
*__restrict__ p;
register ssize_t
x;
register unsigned char
*__restrict__ q;
ssize_t
y;
unsigned char
*pixels;
WebPConfig
configure;
WebPPicture
picture;
WebPAuxStats
statistics;
/*
Open output image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
if (status == MagickFalse)
return(status);
if (WebPPictureInit(&picture) == 0)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
picture.writer=WebPWriter;
picture.custom_ptr=(void *) image;
picture.stats=(&statistics);
picture.width=(int) image->columns;
picture.height=(int) image->rows;
if (image->quality != UndefinedCompressionQuality)
configure.quality=(float) image->quality;
if (WebPConfigInit(&configure) == 0)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
/*
Future: set custom configuration parameters here.
*/
if (WebPValidateConfig(&configure) == 0)
ThrowWriterException(ResourceLimitError,"UnableToEncodeImageFile");
/*
Allocate memory for pixels.
*/
pixels=(unsigned char *) AcquireQuantumMemory(image->columns,
(image->matte != MagickFalse ? 4 : 3)*image->rows*sizeof(*pixels));
if (pixels == (unsigned char *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
/*
Convert image to WebP raster pixels.
*/
q=pixels;
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
if (p == (PixelPacket *) NULL)
break;
for (x=0; x < (ssize_t) image->columns; x++)
{
*q++=ScaleQuantumToChar(GetRedPixelComponent(p));
*q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
*q++=ScaleQuantumToChar(GetBluePixelComponent(p));
if (image->matte != MagickFalse)
*q++=ScaleQuantumToChar((Quantum) (QuantumRange-
(image->matte != MagickFalse ? GetOpacityPixelComponent(p) :
OpaqueOpacity)));
p++;
}
status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
image->rows);
if (status == MagickFalse)
break;
}
if (image->matte == MagickFalse)
webp_status=WebPPictureImportRGB(&picture,pixels,3*picture.width);
else
webp_status=WebPPictureImportRGBA(&picture,pixels,4*picture.width);
pixels=(unsigned char *) RelinquishMagickMemory(pixels);
webp_status=WebPEncode(&configure,&picture);
(void) CloseBlob(image);
return(webp_status == 0 ? MagickFalse : MagickTrue);
}
int main(int argc, const char *argv[]) {
int return_value = -1;
const char *in_file = NULL, *out_file = NULL, *dump_file = NULL;
FILE *out = NULL;
int c;
int short_output = 0;
int quiet = 0;
int keep_alpha = 1;
int blend_alpha = 0;
uint32_t background_color = 0xffffffu;
int crop = 0, crop_x = 0, crop_y = 0, crop_w = 0, crop_h = 0;
int resize_w = 0, resize_h = 0;
int lossless_preset = 6;
int use_lossless_preset = -1; // -1=unset, 0=don't use, 1=use it
int show_progress = 0;
int keep_metadata = 0;
int metadata_written = 0;
WebPPicture picture;
int print_distortion = -1; // -1=off, 0=PSNR, 1=SSIM, 2=LSIM
WebPPicture original_picture; // when PSNR or SSIM is requested
WebPConfig config;
WebPAuxStats stats;
WebPMemoryWriter memory_writer;
Metadata metadata;
Stopwatch stop_watch;
MetadataInit(&metadata);
WebPMemoryWriterInit(&memory_writer);
if (!WebPPictureInit(&picture) ||
!WebPPictureInit(&original_picture) ||
!WebPConfigInit(&config)) {
fprintf(stderr, "Error! Version mismatch!\n");
return -1;
}
if (argc == 1) {
HelpShort();
return 0;
}
for (c = 1; c < argc; ++c) {
if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
HelpShort();
return 0;
} else if (!strcmp(argv[c], "-H") || !strcmp(argv[c], "-longhelp")) {
HelpLong();
return 0;
} else if (!strcmp(argv[c], "-o") && c < argc - 1) {
out_file = argv[++c];
} else if (!strcmp(argv[c], "-d") && c < argc - 1) {
dump_file = argv[++c];
config.show_compressed = 1;
} else if (!strcmp(argv[c], "-print_psnr")) {
config.show_compressed = 1;
print_distortion = 0;
} else if (!strcmp(argv[c], "-print_ssim")) {
config.show_compressed = 1;
print_distortion = 1;
} else if (!strcmp(argv[c], "-print_lsim")) {
config.show_compressed = 1;
print_distortion = 2;
} else if (!strcmp(argv[c], "-short")) {
++short_output;
} else if (!strcmp(argv[c], "-s") && c < argc - 2) {
picture.width = strtol(argv[++c], NULL, 0);
picture.height = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-m") && c < argc - 1) {
config.method = strtol(argv[++c], NULL, 0);
use_lossless_preset = 0; // disable -z option
} else if (!strcmp(argv[c], "-q") && c < argc - 1) {
config.quality = (float)strtod(argv[++c], NULL);
use_lossless_preset = 0; // disable -z option
} else if (!strcmp(argv[c], "-z") && c < argc - 1) {
lossless_preset = strtol(argv[++c], NULL, 0);
if (use_lossless_preset != 0) use_lossless_preset = 1;
} else if (!strcmp(argv[c], "-alpha_q") && c < argc - 1) {
config.alpha_quality = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-alpha_method") && c < argc - 1) {
config.alpha_compression = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-alpha_cleanup")) {
keep_alpha = keep_alpha ? 2 : 0;
} else if (!strcmp(argv[c], "-blend_alpha") && c < argc - 1) {
blend_alpha = 1;
background_color = strtol(argv[++c], NULL, 16); // <- parses '0x' prefix
background_color = background_color & 0x00ffffffu;
} else if (!strcmp(argv[c], "-alpha_filter") && c < argc - 1) {
++c;
if (!strcmp(argv[c], "none")) {
config.alpha_filtering = 0;
} else if (!strcmp(argv[c], "fast")) {
config.alpha_filtering = 1;
} else if (!strcmp(argv[c], "best")) {
config.alpha_filtering = 2;
} else {
fprintf(stderr, "Error! Unrecognized alpha filter: %s\n", argv[c]);
goto Error;
}
} else if (!strcmp(argv[c], "-noalpha")) {
keep_alpha = 0;
} else if (!strcmp(argv[c], "-lossless")) {
config.lossless = 1;
} else if (!strcmp(argv[c], "-hint") && c < argc - 1) {
++c;
if (!strcmp(argv[c], "photo")) {
config.image_hint = WEBP_HINT_PHOTO;
} else if (!strcmp(argv[c], "picture")) {
config.image_hint = WEBP_HINT_PICTURE;
} else if (!strcmp(argv[c], "graph")) {
config.image_hint = WEBP_HINT_GRAPH;
} else {
fprintf(stderr, "Error! Unrecognized image hint: %s\n", argv[c]);
goto Error;
}
} else if (!strcmp(argv[c], "-size") && c < argc - 1) {
config.target_size = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-psnr") && c < argc - 1) {
config.target_PSNR = (float)strtod(argv[++c], NULL);
} else if (!strcmp(argv[c], "-sns") && c < argc - 1) {
config.sns_strength = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-f") && c < argc - 1) {
config.filter_strength = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-af")) {
config.autofilter = 1;
} else if (!strcmp(argv[c], "-jpeg_like")) {
config.emulate_jpeg_size = 1;
} else if (!strcmp(argv[c], "-mt")) {
++config.thread_level; // increase thread level
} else if (!strcmp(argv[c], "-low_memory")) {
config.low_memory = 1;
} else if (!strcmp(argv[c], "-strong")) {
config.filter_type = 1;
} else if (!strcmp(argv[c], "-nostrong")) {
config.filter_type = 0;
} else if (!strcmp(argv[c], "-sharpness") && c < argc - 1) {
config.filter_sharpness = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-pass") && c < argc - 1) {
config.pass = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-pre") && c < argc - 1) {
config.preprocessing = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-segments") && c < argc - 1) {
config.segments = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-partition_limit") && c < argc - 1) {
config.partition_limit = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-map") && c < argc - 1) {
picture.extra_info_type = strtol(argv[++c], NULL, 0);
#ifdef WEBP_EXPERIMENTAL_FEATURES
} else if (!strcmp(argv[c], "-444")) {
picture.colorspace = WEBP_YUV444;
} else if (!strcmp(argv[c], "-422")) {
picture.colorspace = WEBP_YUV422;
} else if (!strcmp(argv[c], "-gray")) {
picture.colorspace = WEBP_YUV400;
#endif
} else if (!strcmp(argv[c], "-crop") && c < argc - 4) {
crop = 1;
crop_x = strtol(argv[++c], NULL, 0);
crop_y = strtol(argv[++c], NULL, 0);
crop_w = strtol(argv[++c], NULL, 0);
crop_h = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-resize") && c < argc - 2) {
resize_w = strtol(argv[++c], NULL, 0);
resize_h = strtol(argv[++c], NULL, 0);
#ifndef WEBP_DLL
} else if (!strcmp(argv[c], "-noasm")) {
VP8GetCPUInfo = NULL;
#endif
} else if (!strcmp(argv[c], "-version")) {
const int version = WebPGetEncoderVersion();
printf("%d.%d.%d\n",
(version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff);
return 0;
} else if (!strcmp(argv[c], "-progress")) {
show_progress = 1;
} else if (!strcmp(argv[c], "-quiet")) {
quiet = 1;
} else if (!strcmp(argv[c], "-preset") && c < argc - 1) {
WebPPreset preset;
++c;
if (!strcmp(argv[c], "default")) {
preset = WEBP_PRESET_DEFAULT;
} else if (!strcmp(argv[c], "photo")) {
preset = WEBP_PRESET_PHOTO;
} else if (!strcmp(argv[c], "picture")) {
preset = WEBP_PRESET_PICTURE;
} else if (!strcmp(argv[c], "drawing")) {
preset = WEBP_PRESET_DRAWING;
} else if (!strcmp(argv[c], "icon")) {
preset = WEBP_PRESET_ICON;
} else if (!strcmp(argv[c], "text")) {
preset = WEBP_PRESET_TEXT;
} else {
fprintf(stderr, "Error! Unrecognized preset: %s\n", argv[c]);
goto Error;
}
if (!WebPConfigPreset(&config, preset, config.quality)) {
fprintf(stderr, "Error! Could initialize configuration with preset.\n");
goto Error;
}
} else if (!strcmp(argv[c], "-metadata") && c < argc - 1) {
static const struct {
const char* option;
int flag;
} kTokens[] = {
{ "all", METADATA_ALL },
{ "none", 0 },
{ "exif", METADATA_EXIF },
{ "icc", METADATA_ICC },
{ "xmp", METADATA_XMP },
};
const size_t kNumTokens = sizeof(kTokens) / sizeof(kTokens[0]);
const char* start = argv[++c];
const char* const end = start + strlen(start);
while (start < end) {
size_t i;
const char* token = strchr(start, ',');
if (token == NULL) token = end;
for (i = 0; i < kNumTokens; ++i) {
if ((size_t)(token - start) == strlen(kTokens[i].option) &&
!strncmp(start, kTokens[i].option, strlen(kTokens[i].option))) {
if (kTokens[i].flag != 0) {
keep_metadata |= kTokens[i].flag;
} else {
keep_metadata = 0;
}
break;
}
}
if (i == kNumTokens) {
fprintf(stderr, "Error! Unknown metadata type '%.*s'\n",
(int)(token - start), start);
HelpLong();
return -1;
}
start = token + 1;
}
#ifdef HAVE_WINCODEC_H
if (keep_metadata != 0 && keep_metadata != METADATA_ICC) {
// TODO(jzern): remove when -metadata is supported on all platforms.
fprintf(stderr, "Warning: only ICC profile extraction is currently"
" supported on this platform!\n");
}
#endif
} else if (!strcmp(argv[c], "-v")) {
verbose = 1;
} else if (!strcmp(argv[c], "--")) {
if (c < argc - 1) in_file = argv[++c];
break;
} else if (argv[c][0] == '-') {
fprintf(stderr, "Error! Unknown option '%s'\n", argv[c]);
HelpLong();
return -1;
} else {
in_file = argv[c];
}
}
GDALDataset *
WEBPDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
/* -------------------------------------------------------------------- */
/* WEBP library initialization */
/* -------------------------------------------------------------------- */
WebPPicture sPicture;
if (!WebPPictureInit(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureInit() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if( nXSize > 16383 || nYSize > 16383 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP maximum image dimensions are 16383 x 16383.");
return NULL;
}
if( nBands != 3
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
&& nBands != 4
#endif
)
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP driver doesn't support %d bands. Must be 3 (RGB) "
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
"or 4 (RGBA) "
#endif
"bands.",
nBands );
return NULL;
}
GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
if( eDT != GDT_Byte )
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"WEBP driver doesn't support data type %s. "
"Only eight bit byte bands supported.",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
if (bStrict)
return NULL;
}
/* -------------------------------------------------------------------- */
/* What options has the user selected? */
/* -------------------------------------------------------------------- */
float fQuality = 75.0f;
const char* pszQUALITY = CSLFetchNameValue(papszOptions, "QUALITY");
if( pszQUALITY != NULL )
{
fQuality = (float) CPLAtof(pszQUALITY);
if( fQuality < 0.0f || fQuality > 100.0f )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "QUALITY", pszQUALITY);
return NULL;
}
}
WebPPreset nPreset = WEBP_PRESET_DEFAULT;
const char* pszPRESET = CSLFetchNameValueDef(papszOptions, "PRESET", "DEFAULT");
if (EQUAL(pszPRESET, "DEFAULT"))
nPreset = WEBP_PRESET_DEFAULT;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "PHOTO"))
nPreset = WEBP_PRESET_PHOTO;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "DRAWING"))
nPreset = WEBP_PRESET_DRAWING;
else if (EQUAL(pszPRESET, "ICON"))
nPreset = WEBP_PRESET_ICON;
else if (EQUAL(pszPRESET, "TEXT"))
nPreset = WEBP_PRESET_TEXT;
else
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "PRESET", pszPRESET );
return NULL;
}
WebPConfig sConfig;
if (!WebPConfigInitInternal(&sConfig, nPreset, fQuality, WEBP_ENCODER_ABI_VERSION))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPConfigInit() failed");
return NULL;
}
#define FETCH_AND_SET_OPTION_INT(name, fieldname, minval, maxval) \
{ \
const char* pszVal = CSLFetchNameValue(papszOptions, name); \
if (pszVal != NULL) \
{ \
sConfig.fieldname = atoi(pszVal); \
if (sConfig.fieldname < minval || sConfig.fieldname > maxval) \
{ \
CPLError( CE_Failure, CPLE_IllegalArg, \
"%s=%s is not a legal value.", name, pszVal ); \
return NULL; \
} \
} \
}
FETCH_AND_SET_OPTION_INT("TARGETSIZE", target_size, 0, INT_MAX);
const char* pszPSNR = CSLFetchNameValue(papszOptions, "PSNR");
if (pszPSNR)
{
sConfig.target_PSNR = CPLAtof(pszPSNR);
if (sConfig.target_PSNR < 0)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"PSNR=%s is not a legal value.", pszPSNR );
return NULL;
}
}
FETCH_AND_SET_OPTION_INT("METHOD", method, 0, 6);
FETCH_AND_SET_OPTION_INT("SEGMENTS", segments, 1, 4);
FETCH_AND_SET_OPTION_INT("SNS_STRENGTH", sns_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_STRENGTH", filter_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_SHARPNESS", filter_sharpness, 0, 7);
FETCH_AND_SET_OPTION_INT("FILTER_TYPE", filter_type, 0, 1);
FETCH_AND_SET_OPTION_INT("AUTOFILTER", autofilter, 0, 1);
FETCH_AND_SET_OPTION_INT("PASS", pass, 1, 10);
FETCH_AND_SET_OPTION_INT("PREPROCESSING", preprocessing, 0, 1);
FETCH_AND_SET_OPTION_INT("PARTITIONS", partitions, 0, 3);
#if WEBP_ENCODER_ABI_VERSION >= 0x0002
FETCH_AND_SET_OPTION_INT("PARTITION_LIMIT", partition_limit, 0, 100);
#endif
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sConfig.lossless = CSLFetchBoolean(papszOptions, "LOSSLESS", FALSE);
if (sConfig.lossless)
sPicture.use_argb = 1;
#endif
if (!WebPValidateConfig(&sConfig))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPValidateConfig() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Allocate memory */
/* -------------------------------------------------------------------- */
GByte *pabyBuffer;
pabyBuffer = (GByte *) VSIMalloc( nBands * nXSize * nYSize );
if (pabyBuffer == NULL)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
VSILFILE *fpImage;
fpImage = VSIFOpenL( pszFilename, "wb" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create WEBP file %s.\n",
pszFilename );
VSIFree(pabyBuffer);
return NULL;
}
WebPUserData sUserData;
sUserData.fp = fpImage;
sUserData.pfnProgress = pfnProgress ? pfnProgress : GDALDummyProgress;
sUserData.pProgressData = pProgressData;
/* -------------------------------------------------------------------- */
/* WEBP library settings */
/* -------------------------------------------------------------------- */
sPicture.width = nXSize;
sPicture.height = nYSize;
sPicture.writer = WEBPDatasetWriter;
sPicture.custom_ptr = &sUserData;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sPicture.progress_hook = WEBPDatasetProgressHook;
#endif
if (!WebPPictureAlloc(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureAlloc() failed");
VSIFree(pabyBuffer);
VSIFCloseL( fpImage );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Acquire source imagery. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
eErr = poSrcDS->RasterIO( GF_Read, 0, 0, nXSize, nYSize,
pabyBuffer, nXSize, nYSize, GDT_Byte,
nBands, NULL,
nBands, nBands * nXSize, 1, NULL );
/* -------------------------------------------------------------------- */
/* Import and write to file */
/* -------------------------------------------------------------------- */
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
if (eErr == CE_None && nBands == 4)
{
if (!WebPPictureImportRGBA(&sPicture, pabyBuffer, nBands * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGBA() failed");
eErr = CE_Failure;
}
}
else
#endif
if (eErr == CE_None &&
!WebPPictureImportRGB(&sPicture, pabyBuffer, nBands * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGB() failed");
eErr = CE_Failure;
}
if (eErr == CE_None && !WebPEncode(&sConfig, &sPicture))
{
const char* pszErrorMsg = NULL;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
switch(sPicture.error_code)
{
case VP8_ENC_ERROR_OUT_OF_MEMORY: pszErrorMsg = "Out of memory"; break;
case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY: pszErrorMsg = "Out of memory while flushing bits"; break;
case VP8_ENC_ERROR_NULL_PARAMETER: pszErrorMsg = "A pointer parameter is NULL"; break;
case VP8_ENC_ERROR_INVALID_CONFIGURATION: pszErrorMsg = "Configuration is invalid"; break;
case VP8_ENC_ERROR_BAD_DIMENSION: pszErrorMsg = "Picture has invalid width/height"; break;
case VP8_ENC_ERROR_PARTITION0_OVERFLOW: pszErrorMsg = "Partition is bigger than 512k. Try using less SEGMENTS, or increase PARTITION_LIMIT value"; break;
case VP8_ENC_ERROR_PARTITION_OVERFLOW: pszErrorMsg = "Partition is bigger than 16M"; break;
case VP8_ENC_ERROR_BAD_WRITE: pszErrorMsg = "Error while flusing bytes"; break;
case VP8_ENC_ERROR_FILE_TOO_BIG: pszErrorMsg = "File is bigger than 4G"; break;
case VP8_ENC_ERROR_USER_ABORT: pszErrorMsg = "User interrupted"; break;
default: break;
}
#endif
if (pszErrorMsg)
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed : %s", pszErrorMsg);
else
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed");
eErr = CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Cleanup and close. */
/* -------------------------------------------------------------------- */
CPLFree( pabyBuffer );
WebPPictureFree(&sPicture);
VSIFCloseL( fpImage );
if( eErr != CE_None )
{
VSIUnlink( pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxiliary pam information. */
/* -------------------------------------------------------------------- */
GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly);
/* If outputing to stdout, we can't reopen it, so we'll return */
/* a fake dataset to make the caller happy */
CPLPushErrorHandler(CPLQuietErrorHandler);
WEBPDataset *poDS = (WEBPDataset*) WEBPDataset::Open( &oOpenInfo );
CPLPopErrorHandler();
if( poDS )
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
return NULL;
}
status_t
WebPTranslator::_TranslateFromBits(BPositionIO* stream, BMessage* ioExtension,
uint32 outType, BPositionIO* target)
{
if (!outType)
outType = WEBP_IMAGE_FORMAT;
if (outType != WEBP_IMAGE_FORMAT)
return B_NO_TRANSLATOR;
TranslatorBitmap bitsHeader;
status_t status;
status = identify_bits_header(stream, NULL, &bitsHeader);
if (status != B_OK)
return status;
if (bitsHeader.colors == B_CMAP8) {
// TODO: support whatever colospace by intermediate colorspace conversion
printf("Error! Colorspace not supported\n");
return B_NO_TRANSLATOR;
}
int32 bitsBytesPerPixel = 0;
switch (bitsHeader.colors) {
case B_RGB32:
case B_RGB32_BIG:
case B_RGBA32:
case B_RGBA32_BIG:
case B_CMY32:
case B_CMYA32:
case B_CMYK32:
bitsBytesPerPixel = 4;
break;
case B_RGB24:
case B_RGB24_BIG:
case B_CMY24:
bitsBytesPerPixel = 3;
break;
case B_RGB16:
case B_RGB16_BIG:
case B_RGBA15:
case B_RGBA15_BIG:
case B_RGB15:
case B_RGB15_BIG:
bitsBytesPerPixel = 2;
break;
case B_CMAP8:
case B_GRAY8:
bitsBytesPerPixel = 1;
break;
default:
return B_ERROR;
}
if (bitsBytesPerPixel < 3) {
// TODO support
return B_NO_TRANSLATOR;
}
WebPPicture picture;
WebPConfig config;
if (!WebPPictureInit(&picture) || !WebPConfigInit(&config)) {
printf("Error! Version mismatch!\n");
return B_ERROR;
}
WebPPreset preset = (WebPPreset)fSettings->SetGetInt32(WEBP_SETTING_PRESET);
config.quality = (float)fSettings->SetGetInt32(WEBP_SETTING_QUALITY);
if (!WebPConfigPreset(&config, (WebPPreset)preset, config.quality)) {
printf("Error! Could initialize configuration with preset.");
return B_ERROR;
}
config.method = fSettings->SetGetInt32(WEBP_SETTING_METHOD);
config.preprocessing = fSettings->SetGetBool(WEBP_SETTING_PREPROCESSING);
if (!WebPValidateConfig(&config)) {
printf("Error! Invalid configuration.\n");
return B_ERROR;
}
picture.width = bitsHeader.bounds.IntegerWidth() + 1;
picture.height = bitsHeader.bounds.IntegerHeight() + 1;
int stride = bitsHeader.rowBytes;
int bitsSize = picture.height * stride;
uint8* bits = (uint8*)malloc(bitsSize);
if (bits == NULL)
return B_NO_MEMORY;
if (stream->Read(bits, bitsSize) != bitsSize) {
free(bits);
return B_IO_ERROR;
}
if (!WebPPictureImportBGRA(&picture, bits, stride)) {
printf("Error! WebPEncode() failed!\n");
free(bits);
return B_ERROR;
}
free(bits);
picture.writer = _EncodedWriter;
picture.custom_ptr = target;
picture.stats = NULL;
if (!WebPEncode(&config, &picture)) {
printf("Error! WebPEncode() failed!\n");
status = B_NO_TRANSLATOR;
} else
status = B_OK;
WebPPictureFree(&picture);
return status;
}
static int
TWebPSetupEncode(TIFF* tif)
{
static const char module[] = "WebPSetupEncode";
uint16 nBitsPerSample = tif->tif_dir.td_bitspersample;
uint16 sampleFormat = tif->tif_dir.td_sampleformat;
WebPState* sp = EncoderState(tif);
assert(sp != NULL);
sp->nSamples = tif->tif_dir.td_samplesperpixel;
/* check band count */
if ( sp->nSamples != 3
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
&& sp->nSamples != 4
#endif
)
{
TIFFErrorExt(tif->tif_clientdata, module,
"WEBP driver doesn't support %d bands. Must be 3 (RGB) "
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
"or 4 (RGBA) "
#endif
"bands.",
sp->nSamples );
return 0;
}
/* check bits per sample and data type */
if ((nBitsPerSample != 8) && (sampleFormat != 1)) {
TIFFErrorExt(tif->tif_clientdata, module,
"WEBP driver requires 8 bit unsigned data");
return 0;
}
if (sp->state & LSTATE_INIT_DECODE) {
WebPIDelete(sp->psDecoder);
WebPFreeDecBuffer(&sp->sDecBuffer);
sp->psDecoder = NULL;
sp->last_y = 0;
sp->state = 0;
}
sp->state |= LSTATE_INIT_ENCODE;
if (!WebPPictureInit(&sp->sPicture)) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error initializing WebP picture.");
return 0;
}
if (!WebPConfigInitInternal(&sp->sEncoderConfig, WEBP_PRESET_DEFAULT,
sp->quality_level,
WEBP_ENCODER_ABI_VERSION)) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error creating WebP encoder configuration.");
return 0;
}
// WebPConfigInitInternal above sets lossless to false
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sp->sEncoderConfig.lossless = sp->lossless;
if (sp->lossless) {
sp->sPicture.use_argb = 1;
}
#endif
if (!WebPValidateConfig(&sp->sEncoderConfig)) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error with WebP encoder configuration.");
return 0;
}
return 1;
}
GDALDataset *
WEBPDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
/* -------------------------------------------------------------------- */
/* WEBP library initialization */
/* -------------------------------------------------------------------- */
WebPPicture sPicture;
if (!WebPPictureInit(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureInit() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if( nXSize > 16383 || nYSize > 16383 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP maximum image dimensions are 16383 x 16383.");
return NULL;
}
if( nBands != 3 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP driver doesn't support %d bands. Must be 3 (RGB) bands.",
nBands );
return NULL;
}
GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
if( eDT != GDT_Byte )
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"WEBP driver doesn't support data type %s. "
"Only eight bit byte bands supported.",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
if (bStrict)
return NULL;
}
/* -------------------------------------------------------------------- */
/* What options has the user selected? */
/* -------------------------------------------------------------------- */
float fQuality = 75.0f;
const char* pszQUALITY = CSLFetchNameValue(papszOptions, "QUALITY");
if( pszQUALITY != NULL )
{
fQuality = (float) atof(pszQUALITY);
if( fQuality < 0.0f || fQuality > 100.0f )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "QUALITY", pszQUALITY);
return NULL;
}
}
WebPPreset nPreset = WEBP_PRESET_DEFAULT;
const char* pszPRESET = CSLFetchNameValueDef(papszOptions, "PRESET", "DEFAULT");
if (EQUAL(pszPRESET, "DEFAULT"))
nPreset = WEBP_PRESET_DEFAULT;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "PHOTO"))
nPreset = WEBP_PRESET_PHOTO;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "DRAWING"))
nPreset = WEBP_PRESET_DRAWING;
else if (EQUAL(pszPRESET, "ICON"))
nPreset = WEBP_PRESET_ICON;
else if (EQUAL(pszPRESET, "TEXT"))
nPreset = WEBP_PRESET_TEXT;
else
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "PRESET", pszPRESET );
return NULL;
}
WebPConfig sConfig;
if (!WebPConfigInitInternal(&sConfig, nPreset, fQuality, WEBP_ENCODER_ABI_VERSION))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPConfigInit() failed");
return NULL;
}
#define FETCH_AND_SET_OPTION_INT(name, fieldname, minval, maxval) \
{ \
const char* pszVal = CSLFetchNameValue(papszOptions, name); \
if (pszVal != NULL) \
{ \
sConfig.fieldname = atoi(pszVal); \
if (sConfig.fieldname < minval || sConfig.fieldname > maxval) \
{ \
CPLError( CE_Failure, CPLE_IllegalArg, \
"%s=%s is not a legal value.", name, pszVal ); \
return NULL; \
} \
} \
}
FETCH_AND_SET_OPTION_INT("TARGETSIZE", target_size, 0, INT_MAX);
const char* pszPSNR = CSLFetchNameValue(papszOptions, "PSNR");
if (pszPSNR)
{
sConfig.target_PSNR = atof(pszPSNR);
if (sConfig.target_PSNR < 0)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"PSNR=%s is not a legal value.", pszPSNR );
return NULL;
}
}
FETCH_AND_SET_OPTION_INT("METHOD", method, 0, 6);
FETCH_AND_SET_OPTION_INT("SEGMENTS", segments, 1, 4);
FETCH_AND_SET_OPTION_INT("SNS_STRENGTH", sns_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_STRENGTH", filter_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_SHARPNESS", filter_sharpness, 0, 7);
FETCH_AND_SET_OPTION_INT("FILTER_TYPE", filter_type, 0, 1);
FETCH_AND_SET_OPTION_INT("AUTOFILTER", autofilter, 0, 1);
FETCH_AND_SET_OPTION_INT("PASS", pass, 1, 10);
FETCH_AND_SET_OPTION_INT("PREPROCESSING", preprocessing, 0, 1);
FETCH_AND_SET_OPTION_INT("PARTITIONS", partitions, 0, 3);
if (!WebPValidateConfig(&sConfig))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPValidateConfig() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Allocate memory */
/* -------------------------------------------------------------------- */
GByte *pabyBuffer;
pabyBuffer = (GByte *) VSIMalloc( 3 * nXSize * nYSize );
if (pabyBuffer == NULL)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
VSILFILE *fpImage;
fpImage = VSIFOpenL( pszFilename, "wb" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create WEBP file %s.\n",
pszFilename );
VSIFree(pabyBuffer);
return NULL;
}
/* -------------------------------------------------------------------- */
/* WEBP library settings */
/* -------------------------------------------------------------------- */
sPicture.colorspace = 0;
sPicture.width = nXSize;
sPicture.height = nYSize;
sPicture.writer = WEBPDatasetWriter;
sPicture.custom_ptr = fpImage;
if (!WebPPictureAlloc(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureAlloc() failed");
VSIFree(pabyBuffer);
VSIFCloseL( fpImage );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Acquire source imagery. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
eErr = poSrcDS->RasterIO( GF_Read, 0, 0, nXSize, nYSize,
pabyBuffer, nXSize, nYSize, GDT_Byte,
3, NULL,
3, 3 * nXSize, 1 );
/* -------------------------------------------------------------------- */
/* Import and write to file */
/* -------------------------------------------------------------------- */
if (eErr == CE_None &&
!WebPPictureImportRGB(&sPicture, pabyBuffer, 3 * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGB() failed");
eErr = CE_Failure;
}
if (eErr == CE_None && !WebPEncode(&sConfig, &sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed");
eErr = CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Cleanup and close. */
/* -------------------------------------------------------------------- */
CPLFree( pabyBuffer );
WebPPictureFree(&sPicture);
VSIFCloseL( fpImage );
if( eErr != CE_None )
{
VSIUnlink( pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxilary pam information. */
/* -------------------------------------------------------------------- */
GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly);
/* If outputing to stdout, we can't reopen it, so we'll return */
/* a fake dataset to make the caller happy */
CPLPushErrorHandler(CPLQuietErrorHandler);
WEBPDataset *poDS = (WEBPDataset*) WEBPDataset::Open( &oOpenInfo );
CPLPopErrorHandler();
if( poDS )
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
return NULL;
}
int webp_encode(const char *in_file, const char *out_file, const FfiWebpEncodeConfig *encode_config) {
int return_value = -1;
FILE *out = NULL;
int keep_alpha = 1;
WebPPicture picture;
WebPConfig config;
// OPTIONS BEGIN
if (encode_config->lossless == 0 || encode_config->lossless == 1){
config.lossless = encode_config->lossless;
}
if (encode_config->quality >= 0 && encode_config->quality <= 100){
config.quality = encode_config->quality;
}
if (encode_config->method >= 0 && encode_config->method <= 6){
config.method = encode_config->method;
}
if (encode_config->target_size > 0){
config.target_size = encode_config->target_size;
}
if (encode_config->target_PSNR > 0){
config.target_PSNR = encode_config->target_PSNR;
}
if (encode_config->segments >= 0 && encode_config->segments <= 4){
config.segments = encode_config->segments;
}
if (encode_config->sns_strength >= 0 && encode_config->sns_strength <= 100){
config.sns_strength = encode_config->sns_strength;
}
if (encode_config->filter_strength >= 0 && encode_config->filter_strength <= 100){
config.filter_strength = encode_config->filter_strength;
}
if (encode_config->filter_sharpness >= 0 && encode_config->filter_sharpness <= 7){
config.filter_sharpness = encode_config->filter_sharpness;
}
if (encode_config->filter_type == 0 || encode_config->filter_type == 1){
config.filter_type = encode_config->filter_type;
}
if (encode_config->autofilter == 0 || encode_config->autofilter == 1){
config.autofilter = encode_config->autofilter;
}
if (encode_config->alpha_compression == 0 || encode_config->alpha_compression == 1){
config.alpha_compression = encode_config->alpha_compression;
}
if (encode_config->alpha_filtering >= 0 && encode_config->alpha_filtering <= 2){
config.alpha_filtering = encode_config->alpha_filtering;
}
if (encode_config->alpha_quality >= 0 && encode_config->alpha_quality <= 100){
config.alpha_quality = encode_config->alpha_quality;
}
if (encode_config->pass >= 0 && encode_config->pass <= 10){
config.pass = encode_config->pass;
}
if (encode_config->show_compressed >= 0){
config.show_compressed = encode_config->show_compressed;
}
if (encode_config->preprocessing == 0 || encode_config->preprocessing == 1){
config.preprocessing = encode_config->preprocessing;
}
if (encode_config->partitions >= 0 && encode_config->partitions <= 3){
config.partitions = encode_config->partitions;
}
if (encode_config->partition_limit >= 0 && encode_config->partition_limit <= 100){
config.partition_limit = encode_config->partition_limit;
}
if ((encode_config->width | encode_config->height) > 0){
picture.width = encode_config->width;
picture.height = encode_config->height;
}
// OPTIONS END
if (!WebPPictureInit(&picture) ||
!WebPConfigInit(&config)) {
//fprintf(stderr, "Error! Version mismatch!\n");
return 1;
}
if (!WebPValidateConfig(&config)) {
//fprintf(stderr, "Error! Invalid configuration.\n");
return_value = 2;
goto Error;
}
if (!UtilReadPicture(in_file, &picture, keep_alpha)) {
//fprintf(stderr, "Error! Cannot read input picture file '%s'\n", in_file);
return_value = 3;
goto Error;
}
out = fopen(out_file, "wb");
if (out == NULL) {
//fprintf(stderr, "Error! Cannot open output file '%s'\n", out_file);
return_value = 4;
goto Error;
}
picture.writer = EncodeWriter;
picture.custom_ptr = (void*)out;
if ((encode_config->crop_w | encode_config->crop_h) > 0){
if (!WebPPictureView(&picture, encode_config->crop_x, encode_config->crop_y, encode_config->crop_w, encode_config->crop_h, &picture)) {
//fprintf(stderr, "Error! Cannot crop picture\n");
return_value = 5;
goto Error;
}
}
if ((encode_config->resize_w | encode_config->resize_h) > 0) {
if (!WebPPictureRescale(&picture, encode_config->resize_w, encode_config->resize_h)) {
//fprintf(stderr, "Error! Cannot resize picture\n");
return_value = 6;
goto Error;
}
}
if (picture.extra_info_type > 0) {
AllocExtraInfo(&picture);
}
if (!WebPEncode(&config, &picture)) {
//fprintf(stderr, "Error! Cannot encode picture as WebP\n");
return_value = 7;
goto Error;
}
return_value = 0;
Error:
free(picture.extra_info);
WebPPictureFree(&picture);
if (out != NULL) {
fclose(out);
}
return return_value;
}
static gboolean
real_save_webp (GdkPixbuf *pixbuf,
gchar **keys,
gchar **values,
GError **error,
gboolean to_callback,
FILE *f,
save_context *context)
{
WebPPicture picture;
WebPConfig config;
gint w, h, rowstride, has_alpha, rc;
guchar *pixels;
if (!WebPPictureInit(&picture) || !WebPConfigInit(&config)) {
g_set_error(error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"WebP encoder version mismatch.");
return FALSE;
}
if (keys && *keys) {
gchar **kiter = keys;
gchar **viter = values;
while (*kiter) {
if (strncmp (*kiter, "quality", 7) == 0) {
float quality = (float) g_ascii_strtod (*viter, NULL);
if (quality < 0 || quality > 100) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"WebP quality must be a value between 0 and 100.");
return FALSE;
}
config.quality = quality;
} else if (strncmp (*kiter, "preset", 6) == 0) {
WebPPreset preset;
if (strncmp (*viter, "default", 7) == 0) {
preset = WEBP_PRESET_DEFAULT;
} else if (strncmp (*viter, "photo", 5) == 0) {
preset = WEBP_PRESET_PHOTO;
} else if (strncmp (*viter, "picture", 7) == 0) {
preset = WEBP_PRESET_PICTURE;
} else if (strncmp (*viter, "drawing", 7) == 0) {
preset = WEBP_PRESET_DRAWING;
} else if (strncmp (*viter, "icon", 4) == 0) {
preset = WEBP_PRESET_ICON;
} else if (strncmp (*viter, "text", 4) == 0) {
preset = WEBP_PRESET_TEXT;
} else {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"WebP encoder invalid preset.");
return FALSE;
}
if (WebPConfigPreset (&config, preset, config.quality) == 0) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
"Could not initialize decoder with preset.");
return FALSE;
}
}
++kiter;
++viter;
}
}
if (WebPValidateConfig (&config) != 1) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_BAD_OPTION,
"Invalid encoding configuration");
return FALSE;
}
w = gdk_pixbuf_get_width (pixbuf);
h = gdk_pixbuf_get_height (pixbuf);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
pixels = gdk_pixbuf_get_pixels (pixbuf);
picture.width = w;
picture.height = h;
if (has_alpha) {
rc = WebPPictureImportRGBA (&picture, pixels, rowstride);
} else {
rc = WebPPictureImportRGB (&picture, pixels, rowstride);
}
if (rc == 0) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
"Failed to allocate picture");
return FALSE;
}
if (to_callback) {
picture.writer = save_callback;
picture.custom_ptr = (void*) context;
} else {
picture.writer = write_file;
picture.custom_ptr = (void*) f;
}
if (WebPEncode(&config, &picture) == 0) {
fprintf(stderr, "Error! Cannot encode picture as WebP\n");
}
return TRUE;
}