blob: b2aea24afad6e6909c244fc0f6688d57e36e8052 [file] [log] [blame]
/*
* Copyright 2010, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "SkImageDecoder.h"
#include "SkImageEncoder.h"
#include "SkColorPriv.h"
#include "SkScaledBitmapSampler.h"
#include "SkStream.h"
#include "SkTemplates.h"
#include "SkUtils.h"
#include "SkTScopedPtr.h"
// A WebP decoder only, on top of (subset of) libwebp
// For more information on WebP image format, and libwebp library, see:
// http://code.google.com/speed/webp/
// http://www.webmproject.org/code/#libwebp_webp_image_decoder_library
// http://review.webmproject.org/gitweb?p=libwebp.git
#include <stdio.h>
extern "C" {
// If moving libwebp out of skia source tree, path for webp headers must be
// updated accordingly. Here, we enforce using local copy in webp sub-directory.
#include "webp/decode.h"
#include "webp/decode_vp8.h"
#include "webp/encode.h"
}
#ifdef ANDROID
#include <cutils/properties.h>
// Key to lookup the size of memory buffer set in system property
static const char KEY_MEM_CAP[] = "ro.media.dec.webp.memcap";
#endif
// this enables timing code to report milliseconds for a decode
//#define TIME_DECODE
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// Define VP8 I/O on top of Skia stream
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
static const size_t WEBP_VP8_HEADER_SIZE = 64;
static const size_t WEBP_IDECODE_BUFFER_SZ = (1 << 16);
// Parse headers of RIFF container, and check for valid Webp (VP8) content.
static bool webp_parse_header(SkStream* stream, int* width, int* height,
int* alpha) {
unsigned char buffer[WEBP_VP8_HEADER_SIZE];
const uint32_t contentSize = stream->getLength();
const size_t len = stream->read(buffer, WEBP_VP8_HEADER_SIZE);
const uint32_t read_bytes = (contentSize < WEBP_VP8_HEADER_SIZE) ?
contentSize : WEBP_VP8_HEADER_SIZE;
if (len != read_bytes) {
return false; // can't read enough
}
WebPBitstreamFeatures features;
VP8StatusCode status = WebPGetFeatures(buffer, read_bytes, &features);
if (status != VP8_STATUS_OK) {
return false; // Invalid WebP file.
}
*width = features.width;
*height = features.height;
*alpha = features.has_alpha;
// sanity check for image size that's about to be decoded.
{
Sk64 size;
size.setMul(*width, *height);
if (size.isNeg() || !size.is32()) {
return false;
}
// now check that if we are 4-bytes per pixel, we also don't overflow
if (size.get32() > (0x7FFFFFFF >> 2)) {
return false;
}
}
return true;
}
class SkWEBPImageDecoder: public SkImageDecoder {
public:
virtual Format getFormat() const {
return kWEBP_Format;
}
protected:
virtual bool onBuildTileIndex(SkStream *stream, int *width, int *height);
virtual bool onDecodeRegion(SkBitmap* bitmap, SkIRect rect);
virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode);
private:
bool setDecodeConfig(SkBitmap* decodedBitmap, int width, int height);
SkStream *inputStream;
int origWidth;
int origHeight;
int hasAlpha;
};
//////////////////////////////////////////////////////////////////////////
#include "SkTime.h"
class AutoTimeMillis {
public:
AutoTimeMillis(const char label[]) :
fLabel(label) {
if (!fLabel) {
fLabel = "";
}
fNow = SkTime::GetMSecs();
}
~AutoTimeMillis() {
SkDebugf("---- Time (ms): %s %d\n", fLabel, SkTime::GetMSecs() - fNow);
}
private:
const char* fLabel;
SkMSec fNow;
};
///////////////////////////////////////////////////////////////////////////////
// This guy exists just to aid in debugging, as it allows debuggers to just
// set a break-point in one place to see all error exists.
static bool return_false(const SkBitmap& bm, const char msg[]) {
#if 0
SkDebugf("libwebp error %s [%d %d]", msg, bm.width(), bm.height());
#endif
return false; // must always return false
}
static WEBP_CSP_MODE webp_decode_mode(SkBitmap* decodedBitmap) {
WEBP_CSP_MODE mode = MODE_LAST;
SkBitmap::Config config = decodedBitmap->config();
if (config == SkBitmap::kARGB_8888_Config) {
mode = MODE_RGBA;
} else if (config == SkBitmap::kARGB_4444_Config) {
mode = MODE_RGBA_4444;
} else if (config == SkBitmap::kRGB_565_Config) {
mode = MODE_RGB_565;
}
return mode;
}
// Incremental WebP image decoding. Reads input buffer of 64K size iteratively
// and decodes this block to appropriate color-space as per config object.
static bool webp_idecode(SkStream* stream, WebPDecoderConfig& config) {
WebPIDecoder* idec = WebPIDecode(NULL, 0, &config);
if (idec == NULL) {
WebPFreeDecBuffer(&config.output);
return false;
}
stream->rewind();
const uint32_t contentSize = stream->getLength();
const uint32_t read_buffer_size = (contentSize < WEBP_IDECODE_BUFFER_SZ) ?
contentSize : WEBP_IDECODE_BUFFER_SZ;
SkAutoMalloc srcStorage(read_buffer_size);
unsigned char* input = (uint8_t*)srcStorage.get();
if (input == NULL) {
WebPIDelete(idec);
WebPFreeDecBuffer(&config.output);
return false;
}
uint32_t bytes_remaining = contentSize;
while (bytes_remaining > 0) {
const uint32_t bytes_to_read =
(bytes_remaining < WEBP_IDECODE_BUFFER_SZ) ?
bytes_remaining : WEBP_IDECODE_BUFFER_SZ;
const size_t bytes_read = stream->read(input, bytes_to_read);
if (bytes_read == 0) {
break;
}
VP8StatusCode status = WebPIAppend(idec, input, bytes_read);
if (status == VP8_STATUS_OK || status == VP8_STATUS_SUSPENDED) {
bytes_remaining -= bytes_read;
} else {
break;
}
}
srcStorage.free();
WebPIDelete(idec);
WebPFreeDecBuffer(&config.output);
if (bytes_remaining > 0) {
return false;
} else {
return true;
}
}
static bool webp_get_config_resize(WebPDecoderConfig& config,
SkBitmap* decodedBitmap,
int width, int height) {
WEBP_CSP_MODE mode = webp_decode_mode(decodedBitmap);
if (mode == MODE_LAST) {
return false;
}
if (WebPInitDecoderConfig(&config) == 0) {
return false;
}
config.output.colorspace = mode;
config.output.u.RGBA.rgba = (uint8_t*)decodedBitmap->getPixels();
config.output.u.RGBA.stride = decodedBitmap->rowBytes();
config.output.u.RGBA.size = decodedBitmap->getSize();
config.output.is_external_memory = 1;
if (width != decodedBitmap->width() ||
height != decodedBitmap->height()) {
config.options.use_scaling = 1;
config.options.scaled_width = decodedBitmap->width();
config.options.scaled_height = decodedBitmap->height();
}
return true;
}
static bool webp_get_config_resize_crop(WebPDecoderConfig& config,
SkBitmap* decodedBitmap,
SkIRect region) {
if (!webp_get_config_resize(config, decodedBitmap,
region.width(), region.height())) return false;
config.options.use_cropping = 1;
config.options.crop_left = region.fLeft;
config.options.crop_top = region.fTop;
config.options.crop_width = region.width();
config.options.crop_height = region.height();
return true;
}
bool SkWEBPImageDecoder::setDecodeConfig(SkBitmap* decodedBitmap,
int width, int height) {
SkBitmap::Config config = this->getPrefConfig(k32Bit_SrcDepth, hasAlpha);
// YUV converter supports output in RGB565, RGBA4444 and RGBA8888 formats.
if (hasAlpha) {
if (config != SkBitmap::kARGB_4444_Config) {
config = SkBitmap::kARGB_8888_Config;
}
} else {
if (config != SkBitmap::kRGB_565_Config &&
config != SkBitmap::kARGB_4444_Config) {
config = SkBitmap::kARGB_8888_Config;
}
}
if (!this->chooseFromOneChoice(config, width, height)) {
return false;
}
decodedBitmap->setConfig(config, width, height, 0);
decodedBitmap->setIsOpaque(!hasAlpha);
return true;
}
bool SkWEBPImageDecoder::onBuildTileIndex(SkStream* stream,
int *width, int *height) {
int origWidth, origHeight, hasAlpha;
if (!webp_parse_header(stream, &origWidth, &origHeight, &hasAlpha)) {
return false;
}
stream->rewind();
*width = origWidth;
*height = origHeight;
this->inputStream = stream;
this->origWidth = origWidth;
this->origHeight = origHeight;
this->hasAlpha = hasAlpha;
return true;
}
static bool isConfigCompatible(SkBitmap* bitmap) {
SkBitmap::Config config = bitmap->config();
return config == SkBitmap::kARGB_4444_Config ||
config == SkBitmap::kRGB_565_Config ||
config == SkBitmap::kARGB_8888_Config;
}
bool SkWEBPImageDecoder::onDecodeRegion(SkBitmap* decodedBitmap,
SkIRect region) {
SkIRect rect = SkIRect::MakeWH(origWidth, origHeight);
if (!rect.intersect(region)) {
// If the requested region is entirely outsides the image, just
// returns false
return false;
}
const int sampleSize = this->getSampleSize();
SkScaledBitmapSampler sampler(rect.width(), rect.height(), sampleSize);
const int width = sampler.scaledWidth();
const int height = sampler.scaledHeight();
// The image can be decoded directly to decodedBitmap if
// 1. the region is within the image range
// 2. bitmap's config is compatible
// 3. bitmap's size is same as the required region (after sampled)
bool directDecode = (rect == region) &&
(decodedBitmap->isNull() ||
(isConfigCompatible(decodedBitmap) &&
(decodedBitmap->width() == width) &&
(decodedBitmap->height() == height)));
SkTScopedPtr<SkBitmap> adb;
SkBitmap *bitmap = decodedBitmap;
if (!directDecode) {
// allocates a temp bitmap
bitmap = new SkBitmap;
adb.reset(bitmap);
}
if (bitmap->isNull()) {
if (!setDecodeConfig(bitmap, width, height)) {
return false;
}
// alloc from native heap if it is a temp bitmap. (prevent GC)
bool allocResult = (bitmap == decodedBitmap)
? allocPixelRef(bitmap, NULL)
: bitmap->allocPixels();
if (!allocResult) {
return return_false(*decodedBitmap, "allocPixelRef");
}
} else {
// This is also called in setDecodeConfig in above block.
// i.e., when bitmap->isNull() is true.
if (!chooseFromOneChoice(bitmap->config(), width, height)) {
return false;
}
}
SkAutoLockPixels alp(*bitmap);
WebPDecoderConfig config;
if (!webp_get_config_resize_crop(config, bitmap, rect)) {
return false;
}
// Decode the WebP image data stream using WebP incremental decoding for
// the specified cropped image-region.
if (!webp_idecode(this->inputStream, config)) {
return false;
}
if (!directDecode) {
cropBitmap(decodedBitmap, bitmap, sampleSize, region.x(), region.y(),
region.width(), region.height(), rect.x(), rect.y());
}
return true;
}
bool SkWEBPImageDecoder::onDecode(SkStream* stream, SkBitmap* decodedBitmap,
Mode mode) {
#ifdef TIME_DECODE
AutoTimeMillis atm("WEBP Decode");
#endif
int origWidth, origHeight, hasAlpha;
if (!webp_parse_header(stream, &origWidth, &origHeight, &hasAlpha)) {
return false;
}
this->hasAlpha = hasAlpha;
const int sampleSize = this->getSampleSize();
SkScaledBitmapSampler sampler(origWidth, origHeight, sampleSize);
// If only bounds are requested, done
if (SkImageDecoder::kDecodeBounds_Mode == mode) {
if (!setDecodeConfig(decodedBitmap, sampler.scaledWidth(),
sampler.scaledHeight())) {
return false;
}
return true;
}
#ifdef SK_BUILD_FOR_ANDROID
// No Bitmap reuse supported for this format
if (!decodedBitmap->isNull()) {
return false;
}
#endif
if (!setDecodeConfig(decodedBitmap, sampler.scaledWidth(),
sampler.scaledHeight())) {
return false;
}
if (!this->allocPixelRef(decodedBitmap, NULL)) {
return return_false(*decodedBitmap, "allocPixelRef");
}
SkAutoLockPixels alp(*decodedBitmap);
WebPDecoderConfig config;
if (!webp_get_config_resize(config, decodedBitmap, origWidth, origHeight)) {
return false;
}
// Decode the WebP image data stream using WebP incremental decoding.
return webp_idecode(stream, config);
}
///////////////////////////////////////////////////////////////////////////////
typedef void (*ScanlineImporter)(const uint8_t* in, uint8_t* out, int width,
const SkPMColor* SK_RESTRICT ctable);
static void ARGB_8888_To_RGB(const uint8_t* in, uint8_t* rgb, int width,
const SkPMColor*) {
const uint32_t* SK_RESTRICT src = (const uint32_t*)in;
for (int i = 0; i < width; ++i) {
const uint32_t c = *src++;
rgb[0] = SkGetPackedR32(c);
rgb[1] = SkGetPackedG32(c);
rgb[2] = SkGetPackedB32(c);
rgb += 3;
}
}
static void RGB_565_To_RGB(const uint8_t* in, uint8_t* rgb, int width,
const SkPMColor*) {
const uint16_t* SK_RESTRICT src = (const uint16_t*)in;
for (int i = 0; i < width; ++i) {
const uint16_t c = *src++;
rgb[0] = SkPacked16ToR32(c);
rgb[1] = SkPacked16ToG32(c);
rgb[2] = SkPacked16ToB32(c);
rgb += 3;
}
}
static void ARGB_4444_To_RGB(const uint8_t* in, uint8_t* rgb, int width,
const SkPMColor*) {
const SkPMColor16* SK_RESTRICT src = (const SkPMColor16*)in;
for (int i = 0; i < width; ++i) {
const SkPMColor16 c = *src++;
rgb[0] = SkPacked4444ToR32(c);
rgb[1] = SkPacked4444ToG32(c);
rgb[2] = SkPacked4444ToB32(c);
rgb += 3;
}
}
static void Index8_To_RGB(const uint8_t* in, uint8_t* rgb, int width,
const SkPMColor* SK_RESTRICT ctable) {
const uint8_t* SK_RESTRICT src = (const uint8_t*)in;
for (int i = 0; i < width; ++i) {
const uint32_t c = ctable[*src++];
rgb[0] = SkGetPackedR32(c);
rgb[1] = SkGetPackedG32(c);
rgb[2] = SkGetPackedB32(c);
rgb += 3;
}
}
static ScanlineImporter ChooseImporter(const SkBitmap::Config& config) {
switch (config) {
case SkBitmap::kARGB_8888_Config:
return ARGB_8888_To_RGB;
case SkBitmap::kRGB_565_Config:
return RGB_565_To_RGB;
case SkBitmap::kARGB_4444_Config:
return ARGB_4444_To_RGB;
case SkBitmap::kIndex8_Config:
return Index8_To_RGB;
default:
return NULL;
}
}
static int StreamWriter(const uint8_t* data, size_t data_size,
const WebPPicture* const picture) {
SkWStream* const stream = (SkWStream*)picture->custom_ptr;
return stream->write(data, data_size) ? 1 : 0;
}
class SkWEBPImageEncoder : public SkImageEncoder {
protected:
virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality);
};
bool SkWEBPImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bm,
int quality) {
const SkBitmap::Config config = bm.getConfig();
const ScanlineImporter scanline_import = ChooseImporter(config);
if (NULL == scanline_import) {
return false;
}
SkAutoLockPixels alp(bm);
SkAutoLockColors ctLocker;
if (NULL == bm.getPixels()) {
return false;
}
WebPConfig webp_config;
if (!WebPConfigPreset(&webp_config, WEBP_PRESET_DEFAULT, quality)) {
return false;
}
WebPPicture pic;
WebPPictureInit(&pic);
pic.width = bm.width();
pic.height = bm.height();
pic.writer = StreamWriter;
pic.custom_ptr = (void*)stream;
const SkPMColor* colors = ctLocker.lockColors(bm);
const uint8_t* src = (uint8_t*)bm.getPixels();
const int rgb_stride = pic.width * 3;
// Import (for each scanline) the bit-map image (in appropriate color-space)
// to RGB color space.
uint8_t* rgb = new uint8_t[rgb_stride * pic.height];
for (int y = 0; y < pic.height; ++y) {
scanline_import(src + y * bm.rowBytes(), rgb + y * rgb_stride,
pic.width, colors);
}
bool ok = WebPPictureImportRGB(&pic, rgb, rgb_stride);
delete[] rgb;
ok = ok && WebPEncode(&webp_config, &pic);
WebPPictureFree(&pic);
return ok;
}
///////////////////////////////////////////////////////////////////////////////
#include "SkTRegistry.h"
static SkImageDecoder* DFactory(SkStream* stream) {
int width, height, hasAlpha;
if (!webp_parse_header(stream, &width, &height, &hasAlpha)) {
return false;
}
// Magic matches, call decoder
return SkNEW(SkWEBPImageDecoder);
}
SkImageDecoder* sk_libwebp_dfactory(SkStream* stream) {
return DFactory(stream);
}
static SkImageEncoder* EFactory(SkImageEncoder::Type t) {
return (SkImageEncoder::kWEBP_Type == t) ? SkNEW(SkWEBPImageEncoder) : NULL;
}
SkImageEncoder* sk_libwebp_efactory(SkImageEncoder::Type t) {
return EFactory(t);
}
static SkTRegistry<SkImageDecoder*, SkStream*> gDReg(sk_libwebp_dfactory);
static SkTRegistry<SkImageEncoder*, SkImageEncoder::Type> gEReg(sk_libwebp_efactory);