int WebPConfigInitInternal(WebPConfig* config,
WebPPreset preset, float quality, int version) {
if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_ENCODER_ABI_VERSION)) {
return 0; // caller/system version mismatch!
}
if (config == NULL) return 0;
config->quality = quality;
config->target_size = 0;
config->target_PSNR = 0.;
config->method = 4;
config->sns_strength = 50;
config->filter_strength = 20; // default: light filtering
config->filter_sharpness = 0;
config->filter_type = 0; // default: simple
config->partitions = 0;
config->segments = 4;
config->pass = 1;
config->show_compressed = 0;
config->preprocessing = 0;
config->autofilter = 0;
config->partition_limit = 0;
config->alpha_compression = 1;
config->alpha_filtering = 1;
config->alpha_quality = 100;
config->lossless = 0;
config->image_hint = WEBP_HINT_DEFAULT;
// TODO(skal): tune.
switch (preset) {
case WEBP_PRESET_PICTURE:
config->sns_strength = 80;
config->filter_sharpness = 4;
config->filter_strength = 35;
break;
case WEBP_PRESET_PHOTO:
config->sns_strength = 80;
config->filter_sharpness = 3;
config->filter_strength = 30;
break;
case WEBP_PRESET_DRAWING:
config->sns_strength = 25;
config->filter_sharpness = 6;
config->filter_strength = 10;
break;
case WEBP_PRESET_ICON:
config->sns_strength = 0;
config->filter_strength = 0; // disable filtering to retain sharpness
break;
case WEBP_PRESET_TEXT:
config->sns_strength = 0;
config->filter_strength = 0; // disable filtering to retain sharpness
config->segments = 2;
break;
case WEBP_PRESET_DEFAULT:
default:
break;
}
return WebPValidateConfig(config);
}
int WebPEncode(const WebPConfig* config, WebPPicture* pic) {
int ok = 0;
if (pic == NULL)
return 0;
WebPEncodingSetError(pic, VP8_ENC_OK); // all ok so far
if (config == NULL) // bad params
return WebPEncodingSetError(pic, VP8_ENC_ERROR_NULL_PARAMETER);
if (!WebPValidateConfig(config))
return WebPEncodingSetError(pic, VP8_ENC_ERROR_INVALID_CONFIGURATION);
if (pic->width <= 0 || pic->height <= 0)
return WebPEncodingSetError(pic, VP8_ENC_ERROR_BAD_DIMENSION);
if (pic->width > WEBP_MAX_DIMENSION || pic->height > WEBP_MAX_DIMENSION)
return WebPEncodingSetError(pic, VP8_ENC_ERROR_BAD_DIMENSION);
if (pic->stats != NULL) memset(pic->stats, 0, sizeof(*pic->stats));
if (!config->lossless) {
VP8Encoder* enc = NULL;
if (pic->y == NULL || pic->u == NULL || pic->v == NULL) {
// Make sure we have YUVA samples.
if (!WebPPictureARGBToYUVA(pic, WEBP_YUV420)) return 0;
}
enc = InitVP8Encoder(config, pic);
if (enc == NULL) return 0; // pic->error is already set.
// Note: each of the tasks below account for 20% in the progress report.
ok = VP8EncAnalyze(enc);
// Analysis is done, proceed to actual coding.
ok = ok && VP8EncStartAlpha(enc); // possibly done in parallel
if (!enc->use_tokens_) {
ok = VP8EncLoop(enc);
} else {
ok = VP8EncTokenLoop(enc);
}
ok = ok && VP8EncFinishAlpha(enc);
#ifdef WEBP_EXPERIMENTAL_FEATURES
ok = ok && VP8EncFinishLayer(enc);
#endif
ok = ok && VP8EncWrite(enc);
StoreStats(enc);
if (!ok) {
VP8EncFreeBitWriters(enc);
}
ok &= DeleteVP8Encoder(enc); // must always be called, even if !ok
} else {
// Make sure we have ARGB samples.
if (pic->argb == NULL && !WebPPictureYUVAToARGB(pic)) {
return 0;
}
ok = VP8LEncodeImage(config, pic); // Sets pic->error in case of problem.
}
return ok;
}
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 gboolean
gst_webp_enc_start (GstVideoEncoder * benc)
{
GstWebpEnc *enc = (GstWebpEnc *) benc;
if (!WebPConfigPreset (&enc->webp_config, enc->preset, enc->quality)) {
GST_ERROR_OBJECT (enc, "Failed to Initialize WebPConfig ");
return FALSE;
}
enc->webp_config.lossless = enc->lossless;
enc->webp_config.method = enc->speed;
if (!WebPValidateConfig (&enc->webp_config)) {
GST_ERROR_OBJECT (enc, "Failed to Validate the WebPConfig");
return FALSE;
}
return TRUE;
}
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 WebPEncode(const WebPConfig* const config, WebPPicture* const pic) {
VP8Encoder* enc;
int ok;
if (pic == NULL)
return 0;
WebPEncodingSetError(pic, VP8_ENC_OK); // all ok so far
if (config == NULL) // bad params
return WebPEncodingSetError(pic, VP8_ENC_ERROR_NULL_PARAMETER);
if (!WebPValidateConfig(config))
return WebPEncodingSetError(pic, VP8_ENC_ERROR_INVALID_CONFIGURATION);
if (pic->width <= 0 || pic->height <= 0)
return WebPEncodingSetError(pic, VP8_ENC_ERROR_BAD_DIMENSION);
if (pic->y == NULL || pic->u == NULL || pic->v == NULL)
return WebPEncodingSetError(pic, VP8_ENC_ERROR_NULL_PARAMETER);
if (pic->width > WEBP_MAX_DIMENSION || pic->height > WEBP_MAX_DIMENSION)
return WebPEncodingSetError(pic, VP8_ENC_ERROR_BAD_DIMENSION);
enc = InitEncoder(config, pic);
if (enc == NULL) return 0; // pic->error is already set.
// Note: each of the tasks below account for 20% in the progress report.
ok = VP8EncAnalyze(enc)
&& VP8StatLoop(enc)
&& VP8EncLoop(enc)
&& VP8EncFinishAlpha(enc)
#ifdef WEBP_EXPERIMENTAL_FEATURES
&& VP8EncFinishLayer(enc)
#endif
&& VP8EncWrite(enc);
StoreStats(enc);
if (!ok) {
VP8EncFreeBitWriters(enc);
}
DeleteEncoder(enc);
return ok;
}
int WebPConfigInitInternal(WebPConfig* config,
WebPPreset preset, float quality, int version) {
if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_ENCODER_ABI_VERSION)) {
return 0; // caller/system version mismatch!
}
if (config == NULL) return 0;
config->quality = quality;
config->target_size = 0;
config->target_PSNR = 0.;
config->method = 4;
config->sns_strength = 50;
config->filter_strength = 60; // mid-filtering
config->filter_sharpness = 0;
config->filter_type = 1; // default: strong (so U/V is filtered too)
config->partitions = 0;
config->segments = 4;
config->pass = 1;
config->show_compressed = 0;
config->preprocessing = 0;
config->autofilter = 0;
config->partition_limit = 0;
config->alpha_compression = 1;
config->alpha_filtering = 1;
config->alpha_quality = 100;
config->lossless = 0;
config->image_hint = WEBP_HINT_DEFAULT;
config->emulate_jpeg_size = 0;
config->thread_level = 0;
config->low_memory = 0;
config->near_lossless = 100;
#ifdef WEBP_EXPERIMENTAL_FEATURES
config->delta_palettization = 0;
#endif // WEBP_EXPERIMENTAL_FEATURES
// TODO(skal): tune.
switch (preset) {
case WEBP_PRESET_PICTURE:
config->sns_strength = 80;
config->filter_sharpness = 4;
config->filter_strength = 35;
config->preprocessing &= ~2; // no dithering
break;
case WEBP_PRESET_PHOTO:
config->sns_strength = 80;
config->filter_sharpness = 3;
config->filter_strength = 30;
config->preprocessing |= 2;
break;
case WEBP_PRESET_DRAWING:
config->sns_strength = 25;
config->filter_sharpness = 6;
config->filter_strength = 10;
break;
case WEBP_PRESET_ICON:
config->sns_strength = 0;
config->filter_strength = 0; // disable filtering to retain sharpness
config->preprocessing &= ~2; // no dithering
break;
case WEBP_PRESET_TEXT:
config->sns_strength = 0;
config->filter_strength = 0; // disable filtering to retain sharpness
config->preprocessing &= ~2; // no dithering
config->segments = 2;
break;
case WEBP_PRESET_DEFAULT:
default:
break;
}
return WebPValidateConfig(config);
}
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);
}
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;
}
}
}
/**
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;
}
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;
}
PyObject* _anim_encoder_add(PyObject* self, PyObject* args)
{
uint8_t* rgb;
Py_ssize_t size;
int timestamp;
int width;
int height;
char* mode;
int lossless;
float quality_factor;
int method;
WebPConfig config;
WebPAnimEncoderObject* encp = (WebPAnimEncoderObject*)self;
WebPAnimEncoder* enc = encp->enc;
WebPPicture* frame = &(encp->frame);
if (!PyArg_ParseTuple(args, "z#iiisifi",
(char**)&rgb, &size, ×tamp, &width, &height, &mode,
&lossless, &quality_factor, &method)) {
return NULL;
}
// Check for NULL frame, which sets duration of final frame
if (!rgb) {
WebPAnimEncoderAdd(enc, NULL, timestamp, NULL);
Py_RETURN_NONE;
}
// Setup config for this frame
if (!WebPConfigInit(&config)) {
PyErr_SetString(PyExc_RuntimeError, "failed to initialize config!");
return NULL;
}
config.lossless = lossless;
config.quality = quality_factor;
config.method = method;
// Validate the config
if (!WebPValidateConfig(&config)) {
PyErr_SetString(PyExc_ValueError, "invalid configuration");
return NULL;
}
// Populate the frame with raw bytes passed to us
frame->width = width;
frame->height = height;
frame->use_argb = 1; // Don't convert RGB pixels to YUV
if (strcmp(mode, "RGBA")==0) {
WebPPictureImportRGBA(frame, rgb, 4 * width);
} else if (strcmp(mode, "RGBX")==0) {
WebPPictureImportRGBX(frame, rgb, 4 * width);
}
// Add the frame to the encoder
if (!WebPAnimEncoderAdd(enc, frame, timestamp, &config)) {
PyErr_SetString(PyExc_RuntimeError, WebPAnimEncoderGetError(enc));
return NULL;
}
Py_RETURN_NONE;
}
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;
}
/**
* 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;
}
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;
}
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 gboolean
_cairo_surface_write_as_webp (cairo_surface_t *image,
char **buffer,
gsize *buffer_size,
char **keys,
char **values,
GError **error)
{
gboolean lossless;
int quality;
int method;
WebPConfig config;
CairoWebpData *cairo_webp_data;
WebPPicture pic;
lossless = TRUE;
quality = 75;
method = 4;
if (keys && *keys) {
char **kiter = keys;
char **viter = values;
while (*kiter) {
if (strcmp (*kiter, "lossless") == 0) {
if (*viter == NULL) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Must specify a value for the 'lossless' option");
return FALSE;
}
lossless = atoi (*viter);
if (lossless < 0 || lossless > 1) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Invalid value set for the 'lossless' option of the WebP saver");
return FALSE;
}
}
else if (strcmp (*kiter, "quality") == 0) {
if (*viter == NULL) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Must specify a quality value to the WebP saver");
return FALSE;
}
quality = atoi (*viter);
if (quality < 0 || quality > 100) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Unsupported quality value passed to the WebP saver");
return FALSE;
}
}
else if (strcmp (*kiter, "method") == 0) {
if (*viter == NULL) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Must specify a method value to the WebP saver");
return FALSE;
}
method = atoi (*viter);
if (method < 0 || method > 6) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Unsupported method value passed to the WebP saver");
return FALSE;
}
}
else {
g_warning ("Bad option name '%s' passed to the WebP saver", *kiter);
return FALSE;
}
++kiter;
++viter;
}
}
if (! WebPConfigInit (&config)) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Version error");
return FALSE;
}
config.lossless = lossless;
config.quality = quality;
config.method = method;
if (! WebPValidateConfig (&config)) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Config error");
return FALSE;
}
cairo_webp_data = g_new0 (CairoWebpData, 1);
cairo_webp_data->error = error;
cairo_webp_data->buffer_data = gth_buffer_data_new ();
cairo_webp_data->success = FALSE;
WebPPictureInit (&pic);
pic.width = cairo_image_surface_get_width (image);
pic.height = cairo_image_surface_get_height (image);
pic.writer = cairo_webp_writer_func;
pic.custom_ptr = cairo_webp_data;
pic.use_argb = TRUE;
if (_WebPPictureImportCairoSurface (&pic, image)) {
int ok = WebPEncode (&config, &pic);
WebPPictureFree (&pic);
if (cairo_webp_data->success && ! ok) {
g_set_error (cairo_webp_data->error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Encoding error: %d", pic.error_code);
cairo_webp_data->success = FALSE;
}
}
else {
g_set_error (cairo_webp_data->error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Memory error");
cairo_webp_data->success = FALSE;
}
if (cairo_webp_data->success)
gth_buffer_data_get (cairo_webp_data->buffer_data, buffer, buffer_size);
_cairo_webp_data_destroy (cairo_webp_data);
return TRUE;
}
int WebPEncode(const WebPConfig* config, WebPPicture* pic) {
int ok = 0;
if (pic == NULL)
return 0;
WebPEncodingSetError(pic, VP8_ENC_OK); // all ok so far
if (config == NULL) // bad params
return WebPEncodingSetError(pic, VP8_ENC_ERROR_NULL_PARAMETER);
if (!WebPValidateConfig(config))
return WebPEncodingSetError(pic, VP8_ENC_ERROR_INVALID_CONFIGURATION);
if (pic->width <= 0 || pic->height <= 0)
return WebPEncodingSetError(pic, VP8_ENC_ERROR_BAD_DIMENSION);
if (pic->width > WEBP_MAX_DIMENSION || pic->height > WEBP_MAX_DIMENSION)
return WebPEncodingSetError(pic, VP8_ENC_ERROR_BAD_DIMENSION);
if (pic->stats != NULL) memset(pic->stats, 0, sizeof(*pic->stats));
if (!config->lossless) {
VP8Encoder* enc = NULL;
if (pic->y == NULL || pic->u == NULL || pic->v == NULL) {
// Make sure we have YUVA samples.
float dithering = 0.f;
if (config->preprocessing & 2) {
const float x = config->quality / 100.f;
const float x2 = x * x;
// slowly decreasing from max dithering at low quality (q->0)
// to 0.5 dithering amplitude at high quality (q->100)
dithering = 1.0f + (0.5f - 1.0f) * x2 * x2;
}
if (!WebPPictureARGBToYUVADithered(pic, WEBP_YUV420, dithering)) {
return 0;
}
}
enc = InitVP8Encoder(config, pic);
if (enc == NULL) return 0; // pic->error is already set.
// Note: each of the tasks below account for 20% in the progress report.
ok = VP8EncAnalyze(enc);
// Analysis is done, proceed to actual coding.
ok = ok && VP8EncStartAlpha(enc); // possibly done in parallel
if (!enc->use_tokens_) {
ok = ok && VP8EncLoop(enc);
} else {
ok = ok && VP8EncTokenLoop(enc);
}
ok = ok && VP8EncFinishAlpha(enc);
ok = ok && VP8EncWrite(enc);
StoreStats(enc);
if (!ok) {
VP8EncFreeBitWriters(enc);
}
ok &= DeleteVP8Encoder(enc); // must always be called, even if !ok
} else {
// Make sure we have ARGB samples.
if (pic->argb == NULL && !WebPPictureYUVAToARGB(pic)) {
return 0;
}
ok = VP8LEncodeImage(config, pic); // Sets pic->error in case of problem.
}
return ok;
}
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;
}
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;
}
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;
}
