| /* |
| * 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 "SkDither.h" |
| #include "SkScaledBitmapSampler.h" |
| #include "SkStream.h" |
| #include "SkTemplates.h" |
| #include "SkUtils.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" |
| } |
| |
| /* If defined, work around missing padding byte in content generated by webpconv */ |
| #define WEBPCONV_MISSING_PADDING 1 |
| |
| #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 |
| |
| ////////////////////////////////////////////////////////////////////////// |
| ////////////////////////////////////////////////////////////////////////// |
| |
| // An helper to extract a integer (little endian) from byte array. This is |
| // called only once per decoding, so no real need to optimize it in any way |
| static uint32_t getint32l(unsigned char *in) { |
| int result; |
| unsigned char *buffer = (unsigned char*) in; |
| |
| if (buffer == NULL) { |
| return 0; |
| } |
| |
| result = buffer[3]; |
| result = (result << 8) + buffer[2]; |
| result = (result << 8) + buffer[1]; |
| result = (result << 8) + buffer[0]; |
| |
| return result; |
| } |
| |
| // Parse headers of RIFF container, and check for valid Webp (VP8) content |
| // return VP8 chunk content size on success, 0 on error. |
| static const size_t WEBP_HEADER_SIZE = 20; |
| static const size_t VP8_HEADER_SIZE = 10; |
| |
| static uint32_t webp_parse_header(SkStream* stream) { |
| unsigned char buffer[WEBP_HEADER_SIZE]; |
| size_t len; |
| uint32_t totalSize; |
| uint32_t contentSize; |
| |
| // RIFF container for WEBP image should always have: |
| // 0 "RIFF" 4-byte tag |
| // 4 size of image data (including metadata) starting at offset 8 |
| // 8 "WEBP" the form-type signature |
| // 12 "VP8 " 4-bytes tags, describing the raw video format used |
| // 16 size of the raw VP8 image data, starting at offset 20 |
| // 20 the VP8 bytes |
| // First check for RIFF top chunk, consuming only 8 bytes |
| len = stream->read(buffer, 8); |
| if (len != 8) { |
| return 0; // can't read enough |
| } |
| // Inline magic matching instead of memcmp() |
| if (buffer[0] != 'R' || buffer[1] != 'I' || buffer[2] != 'F' || buffer[3] != 'F') { |
| return 0; |
| } |
| |
| totalSize = getint32l(buffer + 4); |
| if (totalSize < (int) (WEBP_HEADER_SIZE - 8)) { |
| return 0; |
| } |
| |
| // If RIFF header found, check for RIFF content to start with WEBP/VP8 chunk |
| len = stream->read(buffer + 8, WEBP_HEADER_SIZE - 8); |
| if (len != (int) (WEBP_HEADER_SIZE - 8)) { |
| return 0; |
| } |
| if (buffer[8] != 'W' || buffer[9] != 'E' || buffer[10] != 'B' || buffer[11] != 'P') { |
| return 0; |
| } |
| if (buffer[12] != 'V' || buffer[13] != 'P' || buffer[14] != '8' || buffer[15] != ' ') { |
| return 0; |
| } |
| |
| // Magic matches, extract content size |
| contentSize = getint32l(buffer + 16); |
| |
| // Check consistency of reported sizes |
| if (contentSize <= 0 || contentSize > 0x7fffffff) { |
| return 0; |
| } |
| if (totalSize < 12 + contentSize) { |
| return 0; |
| } |
| if (contentSize & 1) { |
| return 0; |
| } |
| |
| return contentSize; |
| } |
| |
| class SkWEBPImageDecoder: public SkImageDecoder { |
| public: |
| virtual Format getFormat() const { |
| return kWEBP_Format; |
| } |
| |
| protected: |
| virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode); |
| }; |
| |
| ////////////////////////////////////////////////////////////////////////// |
| |
| #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 |
| } |
| |
| typedef struct { |
| SkBitmap* image; |
| SkStream* stream; |
| } WEBPImage; |
| |
| // WebP library embeds its own YUV to RGB converter. However, High-level API doesn't take benefit |
| // of (U,v) clipped values being valid for up to 4 pixels, and so there is a significant improvement |
| // in performance in handling this on our own. |
| // TODO: use architecture-optimized (eventually hardware-accelerated) YUV converters |
| #define YUV_HALF (1 << (YUV_FIX - 1)) |
| #define YUV_FIX 16 // fixed-point precision |
| #define YUV_RANGE_MIN (-227) // min value of r/g/b output |
| #define YUV_RANGE_MAX (256 + 226) // max value of r/g/b output |
| static int16_t VP8kVToR[256], VP8kUToB[256]; |
| static int32_t VP8kVToG[256], VP8kUToG[256]; |
| static uint8_t VP8kClip[YUV_RANGE_MAX - YUV_RANGE_MIN]; |
| |
| static void yuv_init_tables() { |
| int i; |
| |
| for (i = 0; i < 256; ++i) { |
| VP8kVToR[i] = (89858 * (i - 128) + YUV_HALF) >> YUV_FIX; |
| VP8kUToG[i] = -22014 * (i - 128) + YUV_HALF; |
| VP8kVToG[i] = -45773 * (i - 128); |
| VP8kUToB[i] = (113618 * (i - 128) + YUV_HALF) >> YUV_FIX; |
| } |
| for (i = YUV_RANGE_MIN; i < YUV_RANGE_MAX; ++i) { |
| const int k = ((i - 16) * 76283 + YUV_HALF) >> YUV_FIX; |
| VP8kClip[i - YUV_RANGE_MIN] = (k < 0) ? 0 : (k > 255) ? 255 : k; |
| } |
| } |
| |
| // Static global mutex to protect Webp initialization |
| static SkMutex gYUVMutex; |
| static bool gYUVReady = false; |
| |
| static bool yuv_init() { |
| if (!gYUVReady) { |
| gYUVMutex.acquire(); |
| if (!gYUVReady) { |
| yuv_init_tables(); |
| gYUVReady = true; |
| } |
| gYUVMutex.release(); |
| } |
| |
| return gYUVReady; |
| } |
| |
| #define PutRGBA(p,r,g,b) (((SkPMColor*) (p))[0] = SkPackARGB32(0xff,(r),(g),(b))) |
| #define PutRGB565(p,r,g,b) (((SkPMColor16*) (p))[0] = SkPackRGB16((r)>>3,(g)>>2,(b)>>3)) |
| #define PutRGBA4444(p,r,g,b) (((SkPMColor16*) (p))[0] = SkPackARGB4444(0xf,(r)>>4,(g)>>4,(b)>>4)) |
| |
| #define CRGBA(p,y,roff,goff,boff) PutRGBA(p, \ |
| VP8kClip[(y) + (roff) - YUV_RANGE_MIN], \ |
| VP8kClip[(y) + (goff) - YUV_RANGE_MIN], \ |
| VP8kClip[(y) + (boff) - YUV_RANGE_MIN]) |
| #define CRGB565(p,y,roff,goff,boff) PutRGB565(p, \ |
| VP8kClip[(y) + (roff) - YUV_RANGE_MIN], \ |
| VP8kClip[(y) + (goff) - YUV_RANGE_MIN], \ |
| VP8kClip[(y) + (boff) - YUV_RANGE_MIN]) |
| #define CRGBA4444(p,y,roff,goff,boff) PutRGBA4444(p, \ |
| VP8kClip[(y) + (roff) - YUV_RANGE_MIN], \ |
| VP8kClip[(y) + (goff) - YUV_RANGE_MIN], \ |
| VP8kClip[(y) + (boff) - YUV_RANGE_MIN]) |
| |
| static int block_put(const VP8Io* io) { |
| WEBPImage *p = (WEBPImage*) io->opaque; |
| SkBitmap* decodedBitmap = p->image; |
| |
| const int w = io->width; |
| const int mb_h = io->mb_h; |
| |
| const uint8_t *y, *y2, *u, *v; |
| const uint8_t *py, *py2, *pu, *pv; |
| |
| uint8_t* pout; |
| uint8_t* pout2; |
| |
| int i, j; |
| const int ystride2 = io->y_stride * 2; |
| int bpp; |
| SkBitmap::Config config = decodedBitmap->config(); |
| |
| //SkASSERT(!(io->mb_y & 1)); |
| |
| y = io->y; |
| u = io->u; |
| v = io->v; |
| |
| switch (config) { |
| case SkBitmap::kARGB_8888_Config: |
| bpp = 4; |
| break; |
| case SkBitmap::kRGB_565_Config: |
| bpp = 2; |
| break; |
| case SkBitmap::kARGB_4444_Config: |
| bpp = 2; |
| break; |
| default: |
| // Unsupported config |
| return 0; |
| } |
| |
| for (j = 0; j < mb_h;) { |
| pout = decodedBitmap->getAddr8(0, io->mb_y + j); |
| if (j + 1 < mb_h) { |
| y2 = y + io->y_stride; |
| pout2 = decodedBitmap->getAddr8(0, io->mb_y + j + 1); |
| } else { |
| y2 = NULL; |
| pout2 = NULL; |
| } |
| |
| // Copy YUV into target buffer |
| py = y; |
| pu = u; |
| pv = v; |
| |
| py2 = y2; |
| |
| // Leave test for config out of inner loop. This implies some redundancy in code, |
| // but help in supporting several configs without degrading performance. |
| // As a reminder, one must *NOT* put py increment into parameters (i.e. *py++) in the hope to |
| // improve performance or code readability. Since it is used as argument of a macro which uses it |
| // several times in its expression, so this would end up in having it too much incremented |
| switch (config) { |
| case SkBitmap::kARGB_8888_Config: |
| for (i = 0; i < w; i += 2) { |
| // U and V are common for up to 4 pixels |
| const int r_off = VP8kVToR[*pv]; |
| const int g_off = (VP8kVToG[*pv] + VP8kUToG[*pu]) >> YUV_FIX; |
| const int b_off = VP8kUToB[*pu]; |
| |
| CRGBA(pout, *py, r_off, g_off, b_off); |
| pout += bpp; |
| py++; |
| |
| // Width shouldn't be odd, so this should always be true |
| if (i + 1 < w) { |
| CRGBA(pout, *py, r_off, g_off, b_off); |
| pout += bpp; |
| py++; |
| } |
| |
| if (pout2) { |
| CRGBA(pout2, *py2, r_off, g_off, b_off); |
| pout2 += bpp; |
| py2++; |
| |
| // Width shouldn't be odd, so this should always be true |
| if (i + 1 < w) { |
| CRGBA(pout2, *py2, r_off, g_off, b_off); |
| pout2 += bpp; |
| py2++; |
| } |
| } |
| |
| pu++; |
| pv++; |
| } |
| break; |
| case SkBitmap::kRGB_565_Config: |
| for (i = 0; i < w; i += 2) { |
| // U and V are common for up to 4 pixels |
| const int r_off = VP8kVToR[*pv]; |
| const int g_off = (VP8kVToG[*pv] + VP8kUToG[*pu]) >> YUV_FIX; |
| const int b_off = VP8kUToB[*pu]; |
| |
| CRGB565(pout, *py, r_off, g_off, b_off); |
| pout += bpp; |
| py++; |
| |
| // Width shouldn't be odd, so this should always be true |
| if (i + 1 < w) { |
| CRGB565(pout, *py, r_off, g_off, b_off); |
| pout += bpp; |
| py++; |
| } |
| |
| if (pout2) { |
| CRGB565(pout2, *py2, r_off, g_off, b_off); |
| pout2 += bpp; |
| py2++; |
| |
| // Width shouldn't be odd, so this should always be true |
| if (i + 1 < w) { |
| CRGB565(pout2, *py2, r_off, g_off, b_off); |
| pout2 += bpp; |
| py2++; |
| } |
| } |
| |
| pu++; |
| pv++; |
| } |
| break; |
| case SkBitmap::kARGB_4444_Config: |
| for (i = 0; i < w; i += 2) { |
| // U and V are common for up to 4 pixels |
| const int r_off = VP8kVToR[*pv]; |
| const int g_off = (VP8kVToG[*pv] + VP8kUToG[*pu]) >> YUV_FIX; |
| const int b_off = VP8kUToB[*pu]; |
| |
| CRGBA4444(pout, *py, r_off, g_off, b_off); |
| pout += bpp; |
| py++; |
| |
| // Width shouldn't be odd, so this should always be true |
| if (i + 1 < w) { |
| CRGBA4444(pout, *py, r_off, g_off, b_off); |
| pout += bpp; |
| py++; |
| } |
| |
| if (pout2) { |
| CRGBA4444(pout2, *py2, r_off, g_off, b_off); |
| pout2 += bpp; |
| py2++; |
| |
| // Width shouldn't be odd, so this should always be true |
| if (i + 1 < w) { |
| CRGBA4444(pout2, *py2, r_off, g_off, b_off); |
| pout2 += bpp; |
| py2++; |
| } |
| } |
| |
| pu++; |
| pv++; |
| } |
| break; |
| default: |
| // Unsupported config (can't happen, but prevents compiler warning) |
| SkASSERT(0); |
| break; |
| } |
| |
| if (y2) { |
| // Scanned and populated two rows |
| y += ystride2; |
| y2 += ystride2; |
| j += 2; |
| } else { |
| // Skip to next row |
| y += io->y_stride; |
| j++; |
| } |
| |
| u += io->uv_stride; |
| v += io->uv_stride; |
| } |
| |
| return 1; |
| } |
| |
| static int block_setup(VP8Io* io) { |
| yuv_init(); |
| return 1; |
| } |
| |
| static void block_teardown(const VP8Io* io) { |
| } |
| |
| bool SkWEBPImageDecoder::onDecode(SkStream* stream, SkBitmap* decodedBitmap, Mode mode) { |
| #ifdef TIME_DECODE |
| AutoTimeMillis atm("WEBP Decode"); |
| #endif |
| |
| // libwebp doesn't provide a way to override all I/O with a custom |
| // implementation. For initial implementation, let's go the "dirty" |
| // way, by loading image file content in memory before decoding it |
| int origWidth, origHeight; |
| size_t len; |
| |
| bool hasAlpha = false; |
| |
| uint32_t contentSize; |
| unsigned char buffer[VP8_HEADER_SIZE]; |
| unsigned char *input; |
| |
| // Check header |
| contentSize = webp_parse_header(stream); |
| if (contentSize <= VP8_HEADER_SIZE) { |
| return false; |
| } |
| |
| //* Extract information |
| len = stream->read(buffer, VP8_HEADER_SIZE); |
| if (len != VP8_HEADER_SIZE) { |
| return false; |
| } |
| |
| // check signature |
| if (buffer[3] != 0x9d || buffer[4] != 0x01 || buffer[5] != 0x2a) { |
| return false; |
| } |
| |
| const uint32_t bits = buffer[0] | (buffer[1] << 8) | (buffer[2] << 16); |
| const int key_frame = !(bits & 1); |
| |
| origWidth = ((buffer[7] << 8) | buffer[6]) & 0x3fff; |
| origHeight = ((buffer[9] << 8) | buffer[8]) & 0x3fff; |
| |
| if (origWidth <= 0 || origHeight <= 0) { |
| return false; |
| } |
| |
| if (!key_frame) { |
| // Not a keyframe |
| return false; |
| } |
| |
| if (((bits >> 1) & 7) > 3) { |
| // unknown profile |
| return false; |
| } |
| if (!((bits >> 4) & 1)) { |
| // first frame is invisible |
| return false; |
| } |
| if (((bits >> 5)) >= contentSize) { |
| // partition_length inconsistent size information |
| return false; |
| } |
| |
| SkBitmap::Config config; |
| config = this->getPrefConfig(k32Bit_SrcDepth, hasAlpha); |
| |
| // only accept prefConfig if it makes sense for us. 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; |
| } |
| } |
| |
| // sanity check for size |
| { |
| Sk64 size; |
| size.setMul(origWidth, origHeight); |
| 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; |
| } |
| } |
| |
| if (!this->chooseFromOneChoice(config, origWidth, origHeight)) { |
| return false; |
| } |
| |
| // TODO: may add support for sampler, to load previeww/thumbnails faster |
| // Note that, as documented, an image decoder may decide to ignore sample hint from requested |
| // config, so this implementation is still valid and safe even without handling it at all. Several |
| // other Skia image decoders just ignore this optional feature as well. |
| #if 0 |
| SkScaledBitmapSampler sampler(origWidth, origHeight, getSampleSize()); |
| decodedBitmap->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0); |
| #else |
| decodedBitmap->setConfig(config, origWidth, origHeight, 0); |
| #endif |
| |
| // If only bounds are requested, done |
| if (SkImageDecoder::kDecodeBounds_Mode == mode) { |
| return true; |
| } |
| |
| // Current WEBP specification has no support for alpha layer. |
| decodedBitmap->setIsOpaque(true); |
| |
| if (!this->allocPixelRef(decodedBitmap, NULL)) { |
| return return_false(*decodedBitmap, "allocPixelRef"); |
| } |
| SkAutoLockPixels alp(*decodedBitmap); |
| |
| // libwebp doesn't provide a way to override all I/O with a custom |
| // implementation. For initial implementation, let's go the "dirty" |
| // way, by loading image file content (actually only VP8 chunk) into |
| // memory before decoding it */ |
| SkAutoMalloc srcStorage(contentSize); |
| input = (uint8_t*) srcStorage.get(); |
| if (input == NULL) { |
| return return_false(*decodedBitmap, "failed to allocate read buffer"); |
| } |
| |
| len = stream->read(input + VP8_HEADER_SIZE, contentSize - VP8_HEADER_SIZE); |
| #ifdef WEBPCONV_MISSING_PADDING |
| // Some early (yet widely spread) version of webpconv utility |
| // had a bug causing mandatory padding byte to not be written to |
| // file when content size was odd, while total size was reporting |
| // actual file size correctly. Since many webp around may have been |
| // generated with this version of webpconv, work around this issue |
| // by adding padding here. */ |
| // TODO: remove this whenever work-around may be considered obsolete |
| if (len == contentSize - VP8_HEADER_SIZE - 1) { |
| input[VP8_HEADER_SIZE + len] = 0; |
| len++; |
| } |
| #endif |
| if (len != contentSize - VP8_HEADER_SIZE) { |
| return false; |
| } |
| memcpy(input, buffer, VP8_HEADER_SIZE); |
| |
| WEBPImage pSrc; |
| VP8Decoder* dec; |
| VP8Io io; |
| |
| // Custom Put callback need reference to target image |
| pSrc.image = decodedBitmap; |
| |
| // Keep reference to input stream, in case we find a way to not preload stream |
| // content in memory. So far, stream content has already been consumed, and this |
| // won't be used, but this is left for future usage. |
| pSrc.stream = stream; |
| |
| dec = VP8New(); |
| if (dec == NULL) { |
| return false; |
| } |
| |
| VP8InitIo(&io); |
| io.data = input; |
| io.data_size = contentSize; |
| |
| io.opaque = (void*) &pSrc; |
| io.put = block_put; |
| io.setup = block_setup; |
| io.teardown = block_teardown; |
| |
| if (!VP8GetHeaders(dec, &io)) { |
| VP8Delete(dec); |
| return false; |
| } |
| |
| if (!VP8Decode(dec, &io)) { |
| VP8Delete(dec); |
| return false; |
| } |
| |
| VP8Delete(dec); |
| |
| // SkDebugf("------------------- bm2 size %d [%d %d] %d\n", |
| // bm->getSize(), bm->width(), bm->height(), bm->config()); |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| 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) { |
| if (webp_parse_header(stream) <= 0) { |
| return NULL; |
| } |
| |
| // 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); |