bool WEBPImageDecoder::decode(bool onlySize)
{
if (failed())
return false;
const uint8_t* dataBytes = reinterpret_cast<const uint8_t*>(m_data->data());
const size_t dataSize = m_data->size();
if (!ImageDecoder::isSizeAvailable()) {
static const size_t imageHeaderSize = 30;
if (dataSize < imageHeaderSize)
return false;
int width, height;
#ifdef QCMS_WEBP_COLOR_CORRECTION
WebPData inputData = { dataBytes, dataSize };
WebPDemuxState state;
WebPDemuxer* demuxer = WebPDemuxPartial(&inputData, &state);
if (!demuxer)
return setFailed();
width = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_WIDTH);
height = WebPDemuxGetI(demuxer, WEBP_FF_CANVAS_HEIGHT);
m_formatFlags = WebPDemuxGetI(demuxer, WEBP_FF_FORMAT_FLAGS);
m_hasAlpha = !!(m_formatFlags & ALPHA_FLAG);
WebPDemuxDelete(demuxer);
if (state <= WEBP_DEMUX_PARSING_HEADER)
return false;
#elif (WEBP_DECODER_ABI_VERSION >= 0x0163)
WebPBitstreamFeatures features;
if (WebPGetFeatures(dataBytes, dataSize, &features) != VP8_STATUS_OK)
return setFailed();
width = features.width;
height = features.height;
m_hasAlpha = features.has_alpha;
#else
// Earlier version won't be able to display WebP files with alpha.
if (!WebPGetInfo(dataBytes, dataSize, &width, &height))
return setFailed();
m_hasAlpha = false;
#endif
if (!setSize(width, height))
return setFailed();
}
ASSERT(ImageDecoder::isSizeAvailable());
if (onlySize)
return true;
ASSERT(!m_frameBufferCache.isEmpty());
ImageFrame& buffer = m_frameBufferCache[0];
ASSERT(buffer.status() != ImageFrame::FrameComplete);
if (buffer.status() == ImageFrame::FrameEmpty) {
if (!buffer.setSize(size().width(), size().height()))
return setFailed();
buffer.setStatus(ImageFrame::FramePartial);
buffer.setHasAlpha(m_hasAlpha);
buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
}
if (!m_decoder) {
WEBP_CSP_MODE mode = outputMode(m_hasAlpha);
if (!m_premultiplyAlpha)
mode = outputMode(false);
if ((m_formatFlags & ICCP_FLAG) && !ignoresGammaAndColorProfile())
mode = MODE_RGBA; // Decode to RGBA for input to libqcms.
int rowStride = size().width() * sizeof(ImageFrame::PixelData);
uint8_t* output = reinterpret_cast<uint8_t*>(buffer.getAddr(0, 0));
int outputSize = size().height() * rowStride;
m_decoder = WebPINewRGB(mode, output, outputSize, rowStride);
if (!m_decoder)
return setFailed();
}
switch (WebPIUpdate(m_decoder, dataBytes, dataSize)) {
case VP8_STATUS_OK:
if ((m_formatFlags & ICCP_FLAG) && !ignoresGammaAndColorProfile())
applyColorProfile(dataBytes, dataSize, buffer);
buffer.setStatus(ImageFrame::FrameComplete);
clear();
return true;
case VP8_STATUS_SUSPENDED:
if ((m_formatFlags & ICCP_FLAG) && !ignoresGammaAndColorProfile())
applyColorProfile(dataBytes, dataSize, buffer);
return false;
default:
clear();
return setFailed();
}
}
bool WEBPImageDecoder::decode(bool onlySize)
{
if (failed())
return false;
#if defined(__LB_SHELL__)
// We dont want progressive decoding.
if (!isAllDataReceived())
return false;
#endif
const uint8_t* dataBytes = reinterpret_cast<const uint8_t*>(m_data->data());
const size_t dataSize = m_data->size();
if (!ImageDecoder::isSizeAvailable()) {
static const size_t imageHeaderSize = 30;
if (dataSize < imageHeaderSize)
return false;
int width, height;
#if (WEBP_DECODER_ABI_VERSION >= 0x0163)
WebPBitstreamFeatures features;
if (WebPGetFeatures(dataBytes, dataSize, &features) != VP8_STATUS_OK)
return setFailed();
width = features.width;
height = features.height;
m_hasAlpha = features.has_alpha;
#else
// Earlier version won't be able to display WebP files with alpha.
if (!WebPGetInfo(dataBytes, dataSize, &width, &height))
return setFailed();
m_hasAlpha = false;
#endif
if (!setSize(width, height))
return setFailed();
}
ASSERT(ImageDecoder::isSizeAvailable());
if (onlySize)
return true;
ASSERT(!m_frameBufferCache.isEmpty());
ImageFrame& buffer = m_frameBufferCache[0];
ASSERT(buffer.status() != ImageFrame::FrameComplete);
if (buffer.status() == ImageFrame::FrameEmpty) {
if (!buffer.setSize(size().width(), size().height()))
return setFailed();
buffer.setStatus(ImageFrame::FramePartial);
buffer.setHasAlpha(m_hasAlpha);
buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
}
if (!m_decoder) {
int rowStride = size().width() * sizeof(ImageFrame::PixelData);
uint8_t* output = reinterpret_cast<uint8_t*>(buffer.getAddr(0, 0));
int outputSize = size().height() * rowStride;
m_decoder = WebPINewRGB(outputMode(m_hasAlpha), output, outputSize, rowStride);
if (!m_decoder)
return setFailed();
}
switch (WebPIUpdate(m_decoder, dataBytes, dataSize)) {
case VP8_STATUS_OK:
buffer.setStatus(ImageFrame::FrameComplete);
WebPIDelete(m_decoder);
m_decoder = 0;
return true;
case VP8_STATUS_SUSPENDED:
return false;
default:
WebPIDelete(m_decoder);
m_decoder = 0;
return setFailed();
}
}
static gboolean
gdk_pixbuf__webp_image_load_increment (gpointer context,
const guchar *buf, guint size,
GError **error)
{
gint w, h, stride;
WebPContext *data = (WebPContext *) context;
g_return_val_if_fail(data != NULL, FALSE);
if (!data->got_header) {
gint rc;
rc = WebPGetInfo (buf, size, &w, &h);
if (rc == 0) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
"Cannot read WebP image header.");
return FALSE;
}
stride = w * 3; /* TODO Update when alpha support released */
data->got_header = TRUE;
if (data->size_func) {
(* data->size_func) (&w, &h,
data->user_data);
}
data->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
FALSE,
8,
w,
h);
data->decbuf = g_try_malloc (h * stride);
if (!data->decbuf) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
"Cannot allocate memory for decoded image data.");
return FALSE;
}
data->idec = WebPINewRGB (MODE_RGB,
data->decbuf,
h * stride,
stride);
if (!data->idec) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
"Cannot create WebP decoder.");
return FALSE;
}
if (data->prepare_func) {
(* data->prepare_func) (data->pixbuf,
NULL,
data->user_data);
}
}
/* Append size bytes to decoder's buffer */
const VP8StatusCode status = WebPIAppend (data->idec, buf, size);
if (status != VP8_STATUS_SUSPENDED && status != VP8_STATUS_OK) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
"WebP decoder failed with status code %d.",
status);
return FALSE;
}
/* Decode decoder's updated buffer */
guint8 *dec_output;
dec_output = WebPIDecGetRGB (data->idec, &data->last_y, &w, &h, &stride);
if (dec_output == NULL && status != VP8_STATUS_SUSPENDED) {
g_set_error(error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
"Bad inputs to WebP decoder.");
return FALSE;
}
/* Copy decoder output to pixbuf */
gint y, row;
guchar *dptr;
dptr = gdk_pixbuf_get_pixels (data->pixbuf);
const guint8 offset = w % 4; /* decoded width will be divisible by 4 */
for (y = 0; y < data->last_y; ++y, dptr += offset) {
row = y * stride;
g_memmove (dptr + row, dec_output + row, stride);
}
if (data->update_func) {
(* data->update_func) (data->pixbuf, 0, 0,
w,
data->last_y,
data->user_data);
}
return TRUE;
}
bool WEBPImageDecoder::decode(bool onlySize)
{
// Minimum number of bytes needed to ensure one can parse size information.
static const size_t sizeOfHeader = 30;
// Number of bytes per pixel.
static const int bytesPerPixel = 3;
if (failed())
return false;
const size_t dataSize = m_data->size();
if (dataSize < sizeOfHeader)
return true;
int width, height;
const uint8_t* dataBytes = reinterpret_cast<const uint8_t*>(m_data->data());
if (!WebPGetInfo(dataBytes, dataSize, &width, &height))
return setFailed();
if (!ImageDecoder::isSizeAvailable() && !setSize(width, height))
return setFailed();
if (onlySize)
return true;
bool allDataReceived = isAllDataReceived();
int stride = width * bytesPerPixel;
ASSERT(!m_frameBufferCache.isEmpty());
ImageFrame& buffer = m_frameBufferCache[0];
if (buffer.status() == ImageFrame::FrameEmpty) {
ASSERT(width == size().width());
ASSERT(height == size().height());
if (!buffer.setSize(width, height))
return setFailed();
buffer.setStatus(allDataReceived ? ImageFrame::FrameComplete : ImageFrame::FramePartial);
// FIXME: We currently hard code false below because libwebp doesn't support alpha yet.
buffer.setHasAlpha(false);
buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
m_rgbOutput.resize(height * stride);
}
int newLastVisibleRow = 0; // Last completed row.
if (allDataReceived) {
if (!WebPDecodeRGBInto(dataBytes, dataSize, m_rgbOutput.data(), m_rgbOutput.size(), stride))
return setFailed();
newLastVisibleRow = height;
} else {
if (!m_decoder) {
m_decoder = WebPINewRGB(MODE_RGB, m_rgbOutput.data(), m_rgbOutput.size(), stride);
if (!m_decoder)
return setFailed();
}
const VP8StatusCode status = WebPIUpdate(m_decoder, dataBytes, dataSize);
if (status != VP8_STATUS_OK && status != VP8_STATUS_SUSPENDED)
return setFailed();
if (!WebPIDecGetRGB(m_decoder, &newLastVisibleRow, 0, 0, 0))
return setFailed();
ASSERT(newLastVisibleRow >= 0);
ASSERT(newLastVisibleRow <= height);
}
// FIXME: remove this data copy.
for (int y = m_lastVisibleRow; y < newLastVisibleRow; ++y) {
const uint8_t* const src = &m_rgbOutput[y * stride];
for (int x = 0; x < width; ++x)
buffer.setRGBA(x, y, src[bytesPerPixel * x + 0], src[bytesPerPixel * x + 1], src[bytesPerPixel * x + 2], 0xff);
}
m_lastVisibleRow = newLastVisibleRow;
if (m_lastVisibleRow == height)
buffer.setStatus(ImageFrame::FrameComplete);
return m_lastVisibleRow == height;
}
bool WEBPImageDecoder::decode(bool onlySize)
{
#if PLATFORM(CHROMIUM)
TRACE_EVENT("WEBPImageDecoder::decode", this, 0);
#endif
if (failed())
return false;
const uint8_t* dataBytes = reinterpret_cast<const uint8_t*>(m_data->data());
const size_t dataSize = m_data->size();
if (!ImageDecoder::isSizeAvailable()) {
static const size_t imageHeaderSize = 30;
if (dataSize < imageHeaderSize)
return false;
int width, height;
if (!WebPGetInfo(dataBytes, dataSize, &width, &height))
return setFailed();
if (!setSize(width, height))
return setFailed();
}
ASSERT(ImageDecoder::isSizeAvailable());
if (onlySize)
return true;
ASSERT(!m_frameBufferCache.isEmpty());
ImageFrame& buffer = m_frameBufferCache[0];
ASSERT(buffer.status() != ImageFrame::FrameComplete);
if (buffer.status() == ImageFrame::FrameEmpty) {
if (!buffer.setSize(size().width(), size().height()))
return setFailed();
buffer.setStatus(ImageFrame::FramePartial);
buffer.setHasAlpha(false); // FIXME: webp does not support alpha yet.
buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
}
if (!m_decoder) {
int rowStride = size().width() * sizeof(ImageFrame::PixelData);
uint8_t* output = reinterpret_cast<uint8_t*>(buffer.getAddr(0, 0));
int outputSize = size().height() * rowStride;
m_decoder = WebPINewRGB(outputMode(), output, outputSize, rowStride);
if (!m_decoder)
return setFailed();
}
switch (WebPIUpdate(m_decoder, dataBytes, dataSize)) {
case VP8_STATUS_OK:
buffer.setStatus(ImageFrame::FrameComplete);
WebPIDelete(m_decoder);
m_decoder = 0;
return true;
case VP8_STATUS_SUSPENDED:
return false;
default:
WebPIDelete(m_decoder);
m_decoder = 0;
return setFailed();
}
}
