blob: 32801cb3416f4cd75a91955c71b8de2cf490fa62 [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 "src/images/SkImageEncoderPriv.h"
#ifdef SK_HAS_WEBP_LIBRARY
#include "include/core/SkBitmap.h"
#include "include/core/SkStream.h"
#include "include/core/SkUnPreMultiply.h"
#include "include/encode/SkWebpEncoder.h"
#include "include/private/SkColorData.h"
#include "include/private/SkTemplates.h"
#include "src/images/SkImageEncoderFns.h"
#include "src/utils/SkUTF.h"
// A WebP encoder 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/encode.h"
#include "webp/mux.h"
}
static transform_scanline_proc choose_proc(const SkImageInfo& info) {
switch (info.colorType()) {
case kRGBA_8888_SkColorType:
switch (info.alphaType()) {
case kOpaque_SkAlphaType:
return transform_scanline_RGBX;
case kUnpremul_SkAlphaType:
return transform_scanline_memcpy;
case kPremul_SkAlphaType:
return transform_scanline_rgbA;
default:
return nullptr;
}
case kBGRA_8888_SkColorType:
switch (info.alphaType()) {
case kOpaque_SkAlphaType:
return transform_scanline_BGRX;
case kUnpremul_SkAlphaType:
return transform_scanline_BGRA;
case kPremul_SkAlphaType:
return transform_scanline_bgrA;
default:
return nullptr;
}
case kRGB_565_SkColorType:
if (!info.isOpaque()) {
return nullptr;
}
return transform_scanline_565;
case kARGB_4444_SkColorType:
switch (info.alphaType()) {
case kOpaque_SkAlphaType:
return transform_scanline_444;
case kPremul_SkAlphaType:
return transform_scanline_4444;
default:
return nullptr;
}
case kGray_8_SkColorType:
return transform_scanline_gray;
case kRGBA_F16_SkColorType:
switch (info.alphaType()) {
case kOpaque_SkAlphaType:
case kUnpremul_SkAlphaType:
return transform_scanline_F16_to_8888;
case kPremul_SkAlphaType:
return transform_scanline_F16_premul_to_8888;
default:
return nullptr;
}
default:
return nullptr;
}
}
static int stream_writer(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;
}
bool SkWebpEncoder::Encode(SkWStream* stream, const SkPixmap& pixmap, const Options& opts) {
if (!SkPixmapIsValid(pixmap)) {
return false;
}
const transform_scanline_proc proc = choose_proc(pixmap.info());
if (!proc) {
return false;
}
int bpp;
if (kRGBA_F16_SkColorType == pixmap.colorType()) {
bpp = 4;
} else {
bpp = pixmap.isOpaque() ? 3 : 4;
}
if (nullptr == pixmap.addr()) {
return false;
}
WebPConfig webp_config;
if (!WebPConfigPreset(&webp_config, WEBP_PRESET_DEFAULT, opts.fQuality)) {
return false;
}
WebPPicture pic;
WebPPictureInit(&pic);
SkAutoTCallVProc<WebPPicture, WebPPictureFree> autoPic(&pic);
pic.width = pixmap.width();
pic.height = pixmap.height();
pic.writer = stream_writer;
// Set compression, method, and pixel format.
// libwebp recommends using BGRA for lossless and YUV for lossy.
// The choices of |webp_config.method| currently just match Chrome's defaults. We
// could potentially expose this decision to the client.
if (Compression::kLossy == opts.fCompression) {
webp_config.lossless = 0;
#ifndef SK_WEBP_ENCODER_USE_DEFAULT_METHOD
webp_config.method = 3;
#endif
pic.use_argb = 0;
} else {
webp_config.lossless = 1;
webp_config.method = 0;
pic.use_argb = 1;
}
// If there is no need to embed an ICC profile, we write directly to the input stream.
// Otherwise, we will first encode to |tmp| and use a mux to add the ICC chunk. libwebp
// forces us to have an encoded image before we can add a profile.
sk_sp<SkData> icc = icc_from_color_space(pixmap.info());
SkDynamicMemoryWStream tmp;
pic.custom_ptr = icc ? (void*)&tmp : (void*)stream;
const uint8_t* src = (uint8_t*)pixmap.addr();
const int rgbStride = pic.width * bpp;
const size_t rowBytes = pixmap.rowBytes();
// Import (for each scanline) the bit-map image (in appropriate color-space)
// to RGB color space.
std::unique_ptr<uint8_t[]> rgb(new uint8_t[rgbStride * pic.height]);
for (int y = 0; y < pic.height; ++y) {
proc((char*) &rgb[y * rgbStride],
(const char*) &src[y * rowBytes],
pic.width,
bpp);
}
auto importProc = WebPPictureImportRGB;
if (3 != bpp) {
if (pixmap.isOpaque()) {
importProc = WebPPictureImportRGBX;
} else {
importProc = WebPPictureImportRGBA;
}
}
if (!importProc(&pic, &rgb[0], rgbStride)) {
return false;
}
if (!WebPEncode(&webp_config, &pic)) {
return false;
}
if (icc) {
sk_sp<SkData> encodedData = tmp.detachAsData();
WebPData encoded = { encodedData->bytes(), encodedData->size() };
WebPData iccChunk = { icc->bytes(), icc->size() };
SkAutoTCallVProc<WebPMux, WebPMuxDelete> mux(WebPMuxNew());
if (WEBP_MUX_OK != WebPMuxSetImage(mux, &encoded, 0)) {
return false;
}
if (WEBP_MUX_OK != WebPMuxSetChunk(mux, "ICCP", &iccChunk, 0)) {
return false;
}
WebPData assembled;
if (WEBP_MUX_OK != WebPMuxAssemble(mux, &assembled)) {
return false;
}
stream->write(assembled.bytes, assembled.size);
WebPDataClear(&assembled);
}
return true;
}
#endif