netsurf/content/handlers/image/webp.c
2020-05-08 09:08:31 +01:00

236 lines
5.2 KiB
C

/*
* Copyright 2019 Vincent Sanders <vince@netsurf-browser.org>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* NetSurf is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* \file
* implementation of content handling for image/webp
*
* This implementation uses the google webp library.
* Image cache handling is performed by the generic NetSurf handler.
*/
#include <stdbool.h>
#include <stdlib.h>
#include <setjmp.h>
#include <webp/decode.h>
#include "utils/utils.h"
#include "utils/log.h"
#include "utils/messages.h"
#include "netsurf/bitmap.h"
#include "content/llcache.h"
#include "content/content_protected.h"
#include "content/content_factory.h"
#include "desktop/gui_internal.h"
#include "image/image_cache.h"
#include "webp.h"
/**
* Content create entry point.
*
* create a content object for the webp
*/
static nserror
webp_create(const content_handler *handler,
lwc_string *imime_type,
const struct http_parameter *params,
llcache_handle *llcache,
const char *fallback_charset,
bool quirks,
struct content **c)
{
struct content *webp_c; /* webp content object */
nserror res;
webp_c = calloc(1, sizeof(struct content));
if (webp_c == NULL) {
return NSERROR_NOMEM;
}
res = content__init(webp_c,
handler,
imime_type,
params,
llcache,
fallback_charset,
quirks);
if (res != NSERROR_OK) {
free(webp_c);
return res;
}
*c = webp_c;
return NSERROR_OK;
}
/**
* create a bitmap from webp content.
*/
static struct bitmap *
webp_cache_convert(struct content *c)
{
const uint8_t *source_data; /* webp source data */
size_t source_size; /* length of webp source data */
VP8StatusCode webpres;
WebPBitstreamFeatures webpfeatures;
unsigned int bmap_flags;
uint8_t *pixels = NULL;
uint8_t *decoded;
size_t rowstride;
struct bitmap *bitmap = NULL;
source_data = content__get_source_data(c, &source_size);
webpres = WebPGetFeatures(source_data, source_size, &webpfeatures);
if (webpres != VP8_STATUS_OK) {
return NULL;
}
if (webpfeatures.has_alpha == 0) {
bmap_flags = BITMAP_NEW | BITMAP_OPAQUE;
} else {
bmap_flags = BITMAP_NEW;
}
/* create bitmap */
bitmap = guit->bitmap->create(webpfeatures.width,
webpfeatures.height,
bmap_flags);
if (bitmap == NULL) {
/* empty bitmap could not be created */
return NULL;
}
pixels = guit->bitmap->get_buffer(bitmap);
if (pixels == NULL) {
/* bitmap with no buffer available */
guit->bitmap->destroy(bitmap);
return NULL;
}
rowstride = guit->bitmap->get_rowstride(bitmap);
decoded = WebPDecodeRGBAInto(source_data,
source_size,
pixels,
webpfeatures.width * webpfeatures.height * 4,
rowstride);
if (decoded == NULL) {
/* decode failed */
guit->bitmap->destroy(bitmap);
return NULL;
}
guit->bitmap->modified(bitmap);
return bitmap;
}
/**
* Convert the webp source data content.
*
* This ensures there is valid webp source data in the content object
* and then adds it to the image cache ready to be converted on
* demand.
*
* \param c The webp content object
* \return true on successful processing of teh webp content else false
*/
static bool webp_convert(struct content *c)
{
int res;
const uint8_t* data;
size_t data_size;
int width;
int height;
data = content__get_source_data(c, &data_size);
res = WebPGetInfo(data, data_size, &width, &height);
if (res == 0) {
NSLOG(netsurf, INFO, "WebPGetInfo failed:%p", c);
return false;
}
c->width = width;
c->height = height;
c->size = c->width * c->height * 4;
image_cache_add(c, NULL, webp_cache_convert);
content_set_ready(c);
content_set_done(c);
return true;
}
/**
* Clone content.
*/
static nserror webp_clone(const struct content *old, struct content **new_c)
{
struct content *webp_c; /* cloned webp content */
nserror res;
webp_c = calloc(1, sizeof(struct content));
if (webp_c == NULL) {
return NSERROR_NOMEM;
}
res = content__clone(old, webp_c);
if (res != NSERROR_OK) {
content_destroy(webp_c);
return res;
}
/* re-convert if the content is ready */
if ((old->status == CONTENT_STATUS_READY) ||
(old->status == CONTENT_STATUS_DONE)) {
if (webp_convert(webp_c) == false) {
content_destroy(webp_c);
return NSERROR_CLONE_FAILED;
}
}
*new_c = webp_c;
return NSERROR_OK;
}
static const content_handler webp_content_handler = {
.create = webp_create,
.data_complete = webp_convert,
.destroy = image_cache_destroy,
.redraw = image_cache_redraw,
.clone = webp_clone,
.get_internal = image_cache_get_internal,
.type = image_cache_content_type,
.no_share = false,
};
static const char *webp_types[] = {
"image/webp"
};
CONTENT_FACTORY_REGISTER_TYPES(nswebp, webp_types, webp_content_handler);