// Copyright 2015 Google Inc. All Rights Reserved. // // Use of this source code is governed by a BSD-style license // that can be found in the COPYING file in the root of the source // tree. An additional intellectual property rights grant can be found // in the file PATENTS. All contributing project authors may // be found in the AUTHORS file in the root of the source tree. // ----------------------------------------------------------------------------- // // AnimDecoder implementation. // #ifdef HAVE_CONFIG_H #include "src/webp/config.h" #endif #include <assert.h> #include <string.h> #include "src/utils/utils.h" #include "src/webp/decode.h" #include "src/webp/demux.h" #define NUM_CHANNELS 4 typedef void (*BlendRowFunc)(uint32_t* const, const uint32_t* const, int); static void BlendPixelRowNonPremult(uint32_t* const src, const uint32_t* const dst, int num_pixels); static void BlendPixelRowPremult(uint32_t* const src, const uint32_t* const dst, int num_pixels); struct WebPAnimDecoder { WebPDemuxer* demux_; // Demuxer created from given WebP bitstream. WebPDecoderConfig config_; // Decoder config. // Note: we use a pointer to a function blending multiple pixels at a time to // allow possible inlining of per-pixel blending function. BlendRowFunc blend_func_; // Pointer to the chose blend row function. WebPAnimInfo info_; // Global info about the animation. uint8_t* curr_frame_; // Current canvas (not disposed). uint8_t* prev_frame_disposed_; // Previous canvas (properly disposed). int prev_frame_timestamp_; // Previous frame timestamp (milliseconds). WebPIterator prev_iter_; // Iterator object for previous frame. int prev_frame_was_keyframe_; // True if previous frame was a keyframe. int next_frame_; // Index of the next frame to be decoded // (starting from 1). }; static void DefaultDecoderOptions(WebPAnimDecoderOptions* const dec_options) { dec_options->color_mode = MODE_RGBA; dec_options->use_threads = 0; } int WebPAnimDecoderOptionsInitInternal(WebPAnimDecoderOptions* dec_options, int abi_version) { if (dec_options == NULL || WEBP_ABI_IS_INCOMPATIBLE(abi_version, WEBP_DEMUX_ABI_VERSION)) { return 0; } DefaultDecoderOptions(dec_options); return 1; } static int ApplyDecoderOptions(const WebPAnimDecoderOptions* const dec_options, WebPAnimDecoder* const dec) { WEBP_CSP_MODE mode; WebPDecoderConfig* config = &dec->config_; assert(dec_options != NULL); mode = dec_options->color_mode; if (mode != MODE_RGBA && mode != MODE_BGRA && mode != MODE_rgbA && mode != MODE_bgrA) { return 0; } dec->blend_func_ = (mode == MODE_RGBA || mode == MODE_BGRA) ? &BlendPixelRowNonPremult : &BlendPixelRowPremult; WebPInitDecoderConfig(config); config->output.colorspace = mode; config->output.is_external_memory = 1; config->options.use_threads = dec_options->use_threads; // Note: config->output.u.RGBA is set at the time of decoding each frame. return 1; } WebPAnimDecoder* WebPAnimDecoderNewInternal( const WebPData* webp_data, const WebPAnimDecoderOptions* dec_options, int abi_version) { WebPAnimDecoderOptions options; WebPAnimDecoder* dec = NULL; if (webp_data == NULL || WEBP_ABI_IS_INCOMPATIBLE(abi_version, WEBP_DEMUX_ABI_VERSION)) { return NULL; } // Note: calloc() so that the pointer members are initialized to NULL. dec = (WebPAnimDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec)); if (dec == NULL) goto Error; if (dec_options != NULL) { options = *dec_options; } else { DefaultDecoderOptions(&options); } if (!ApplyDecoderOptions(&options, dec)) goto Error; dec->demux_ = WebPDemux(webp_data); if (dec->demux_ == NULL) goto Error; dec->info_.canvas_width = WebPDemuxGetI(dec->demux_, WEBP_FF_CANVAS_WIDTH); dec->info_.canvas_height = WebPDemuxGetI(dec->demux_, WEBP_FF_CANVAS_HEIGHT); dec->info_.loop_count = WebPDemuxGetI(dec->demux_, WEBP_FF_LOOP_COUNT); dec->info_.bgcolor = WebPDemuxGetI(dec->demux_, WEBP_FF_BACKGROUND_COLOR); dec->info_.frame_count = WebPDemuxGetI(dec->demux_, WEBP_FF_FRAME_COUNT); // Note: calloc() because we fill frame with zeroes as well. dec->curr_frame_ = (uint8_t*)WebPSafeCalloc( dec->info_.canvas_width * NUM_CHANNELS, dec->info_.canvas_height); if (dec->curr_frame_ == NULL) goto Error; dec->prev_frame_disposed_ = (uint8_t*)WebPSafeCalloc( dec->info_.canvas_width * NUM_CHANNELS, dec->info_.canvas_height); if (dec->prev_frame_disposed_ == NULL) goto Error; WebPAnimDecoderReset(dec); return dec; Error: WebPAnimDecoderDelete(dec); return NULL; } int WebPAnimDecoderGetInfo(const WebPAnimDecoder* dec, WebPAnimInfo* info) { if (dec == NULL || info == NULL) return 0; *info = dec->info_; return 1; } // Returns true if the frame covers the full canvas. static int IsFullFrame(int width, int height, int canvas_width, int canvas_height) { return (width == canvas_width && height == canvas_height); } // Clear the canvas to transparent. static int ZeroFillCanvas(uint8_t* buf, uint32_t canvas_width, uint32_t canvas_height) { const uint64_t size = (uint64_t)canvas_width * canvas_height * NUM_CHANNELS * sizeof(*buf); if (size != (size_t)size) return 0; memset(buf, 0, (size_t)size); return 1; } // Clear given frame rectangle to transparent. static void ZeroFillFrameRect(uint8_t* buf, int buf_stride, int x_offset, int y_offset, int width, int height) { int j; assert(width * NUM_CHANNELS <= buf_stride); buf += y_offset * buf_stride + x_offset * NUM_CHANNELS; for (j = 0; j < height; ++j) { memset(buf, 0, width * NUM_CHANNELS); buf += buf_stride; } } // Copy width * height pixels from 'src' to 'dst'. static int CopyCanvas(const uint8_t* src, uint8_t* dst, uint32_t width, uint32_t height) { const uint64_t size = (uint64_t)width * height * NUM_CHANNELS; if (size != (size_t)size) return 0; assert(src != NULL && dst != NULL); memcpy(dst, src, (size_t)size); return 1; } // Returns true if the current frame is a key-frame. static int IsKeyFrame(const WebPIterator* const curr, const WebPIterator* const prev, int prev_frame_was_key_frame, int canvas_width, int canvas_height) { if (curr->frame_num == 1) { return 1; } else if ((!curr->has_alpha || curr->blend_method == WEBP_MUX_NO_BLEND) && IsFullFrame(curr->width, curr->height, canvas_width, canvas_height)) { return 1; } else { return (prev->dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) && (IsFullFrame(prev->width, prev->height, canvas_width, canvas_height) || prev_frame_was_key_frame); } } // Blend a single channel of 'src' over 'dst', given their alpha channel values. // 'src' and 'dst' are assumed to be NOT pre-multiplied by alpha. static uint8_t BlendChannelNonPremult(uint32_t src, uint8_t src_a, uint32_t dst, uint8_t dst_a, uint32_t scale, int shift) { const uint8_t src_channel = (src >> shift) & 0xff; const uint8_t dst_channel = (dst >> shift) & 0xff; const uint32_t blend_unscaled = src_channel * src_a + dst_channel * dst_a; assert(blend_unscaled < (1ULL << 32) / scale); return (blend_unscaled * scale) >> 24; } // Blend 'src' over 'dst' assuming they are NOT pre-multiplied by alpha. static uint32_t BlendPixelNonPremult(uint32_t src, uint32_t dst) { const uint8_t src_a = (src >> 24) & 0xff; if (src_a == 0) { return dst; } else { const uint8_t dst_a = (dst >> 24) & 0xff; // This is the approximate integer arithmetic for the actual formula: // dst_factor_a = (dst_a * (255 - src_a)) / 255. const uint8_t dst_factor_a = (dst_a * (256 - src_a)) >> 8; const uint8_t blend_a = src_a + dst_factor_a; const uint32_t scale = (1UL << 24) / blend_a; const uint8_t blend_r = BlendChannelNonPremult(src, src_a, dst, dst_factor_a, scale, 0); const uint8_t blend_g = BlendChannelNonPremult(src, src_a, dst, dst_factor_a, scale, 8); const uint8_t blend_b = BlendChannelNonPremult(src, src_a, dst, dst_factor_a, scale, 16); assert(src_a + dst_factor_a < 256); return (blend_r << 0) | (blend_g << 8) | (blend_b << 16) | ((uint32_t)blend_a << 24); } } // Blend 'num_pixels' in 'src' over 'dst' assuming they are NOT pre-multiplied // by alpha. static void BlendPixelRowNonPremult(uint32_t* const src, const uint32_t* const dst, int num_pixels) { int i; for (i = 0; i < num_pixels; ++i) { const uint8_t src_alpha = (src[i] >> 24) & 0xff; if (src_alpha != 0xff) { src[i] = BlendPixelNonPremult(src[i], dst[i]); } } } // Individually multiply each channel in 'pix' by 'scale'. static WEBP_INLINE uint32_t ChannelwiseMultiply(uint32_t pix, uint32_t scale) { uint32_t mask = 0x00FF00FF; uint32_t rb = ((pix & mask) * scale) >> 8; uint32_t ag = ((pix >> 8) & mask) * scale; return (rb & mask) | (ag & ~mask); } // Blend 'src' over 'dst' assuming they are pre-multiplied by alpha. static uint32_t BlendPixelPremult(uint32_t src, uint32_t dst) { const uint8_t src_a = (src >> 24) & 0xff; return src + ChannelwiseMultiply(dst, 256 - src_a); } // Blend 'num_pixels' in 'src' over 'dst' assuming they are pre-multiplied by // alpha. static void BlendPixelRowPremult(uint32_t* const src, const uint32_t* const dst, int num_pixels) { int i; for (i = 0; i < num_pixels; ++i) { const uint8_t src_alpha = (src[i] >> 24) & 0xff; if (src_alpha != 0xff) { src[i] = BlendPixelPremult(src[i], dst[i]); } } } // Returns two ranges (<left, width> pairs) at row 'canvas_y', that belong to // 'src' but not 'dst'. A point range is empty if the corresponding width is 0. static void FindBlendRangeAtRow(const WebPIterator* const src, const WebPIterator* const dst, int canvas_y, int* const left1, int* const width1, int* const left2, int* const width2) { const int src_max_x = src->x_offset + src->width; const int dst_max_x = dst->x_offset + dst->width; const int dst_max_y = dst->y_offset + dst->height; assert(canvas_y >= src->y_offset && canvas_y < (src->y_offset + src->height)); *left1 = -1; *width1 = 0; *left2 = -1; *width2 = 0; if (canvas_y < dst->y_offset || canvas_y >= dst_max_y || src->x_offset >= dst_max_x || src_max_x <= dst->x_offset) { *left1 = src->x_offset; *width1 = src->width; return; } if (src->x_offset < dst->x_offset) { *left1 = src->x_offset; *width1 = dst->x_offset - src->x_offset; } if (src_max_x > dst_max_x) { *left2 = dst_max_x; *width2 = src_max_x - dst_max_x; } } int WebPAnimDecoderGetNext(WebPAnimDecoder* dec, uint8_t** buf_ptr, int* timestamp_ptr) { WebPIterator iter; uint32_t width; uint32_t height; int is_key_frame; int timestamp; BlendRowFunc blend_row; if (dec == NULL || buf_ptr == NULL || timestamp_ptr == NULL) return 0; if (!WebPAnimDecoderHasMoreFrames(dec)) return 0; width = dec->info_.canvas_width; height = dec->info_.canvas_height; blend_row = dec->blend_func_; // Get compressed frame. if (!WebPDemuxGetFrame(dec->demux_, dec->next_frame_, &iter)) { return 0; } timestamp = dec->prev_frame_timestamp_ + iter.duration; // Initialize. is_key_frame = IsKeyFrame(&iter, &dec->prev_iter_, dec->prev_frame_was_keyframe_, width, height); if (is_key_frame) { if (!ZeroFillCanvas(dec->curr_frame_, width, height)) { goto Error; } } else { if (!CopyCanvas(dec->prev_frame_disposed_, dec->curr_frame_, width, height)) { goto Error; } } // Decode. { const uint8_t* in = iter.fragment.bytes; const size_t in_size = iter.fragment.size; const size_t out_offset = (iter.y_offset * width + iter.x_offset) * NUM_CHANNELS; WebPDecoderConfig* const config = &dec->config_; WebPRGBABuffer* const buf = &config->output.u.RGBA; buf->stride = NUM_CHANNELS * width; buf->size = buf->stride * iter.height; buf->rgba = dec->curr_frame_ + out_offset; if (WebPDecode(in, in_size, config) != VP8_STATUS_OK) { goto Error; } } // During the decoding of current frame, we may have set some pixels to be // transparent (i.e. alpha < 255). However, the value of each of these // pixels should have been determined by blending it against the value of // that pixel in the previous frame if blending method of is WEBP_MUX_BLEND. if (iter.frame_num > 1 && iter.blend_method == WEBP_MUX_BLEND && !is_key_frame) { if (dec->prev_iter_.dispose_method == WEBP_MUX_DISPOSE_NONE) { int y; // Blend transparent pixels with pixels in previous canvas. for (y = 0; y < iter.height; ++y) { const size_t offset = (iter.y_offset + y) * width + iter.x_offset; blend_row((uint32_t*)dec->curr_frame_ + offset, (uint32_t*)dec->prev_frame_disposed_ + offset, iter.width); } } else { int y; assert(dec->prev_iter_.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND); // We need to blend a transparent pixel with its value just after // initialization. That is, blend it with: // * Fully transparent pixel if it belongs to prevRect <-- No-op. // * The pixel in the previous canvas otherwise <-- Need alpha-blending. for (y = 0; y < iter.height; ++y) { const int canvas_y = iter.y_offset + y; int left1, width1, left2, width2; FindBlendRangeAtRow(&iter, &dec->prev_iter_, canvas_y, &left1, &width1, &left2, &width2); if (width1 > 0) { const size_t offset1 = canvas_y * width + left1; blend_row((uint32_t*)dec->curr_frame_ + offset1, (uint32_t*)dec->prev_frame_disposed_ + offset1, width1); } if (width2 > 0) { const size_t offset2 = canvas_y * width + left2; blend_row((uint32_t*)dec->curr_frame_ + offset2, (uint32_t*)dec->prev_frame_disposed_ + offset2, width2); } } } } // Update info of the previous frame and dispose it for the next iteration. dec->prev_frame_timestamp_ = timestamp; WebPDemuxReleaseIterator(&dec->prev_iter_); dec->prev_iter_ = iter; dec->prev_frame_was_keyframe_ = is_key_frame; CopyCanvas(dec->curr_frame_, dec->prev_frame_disposed_, width, height); if (dec->prev_iter_.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) { ZeroFillFrameRect(dec->prev_frame_disposed_, width * NUM_CHANNELS, dec->prev_iter_.x_offset, dec->prev_iter_.y_offset, dec->prev_iter_.width, dec->prev_iter_.height); } ++dec->next_frame_; // All OK, fill in the values. *buf_ptr = dec->curr_frame_; *timestamp_ptr = timestamp; return 1; Error: WebPDemuxReleaseIterator(&iter); return 0; } int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec) { if (dec == NULL) return 0; return (dec->next_frame_ <= (int)dec->info_.frame_count); } void WebPAnimDecoderReset(WebPAnimDecoder* dec) { if (dec != NULL) { dec->prev_frame_timestamp_ = 0; WebPDemuxReleaseIterator(&dec->prev_iter_); memset(&dec->prev_iter_, 0, sizeof(dec->prev_iter_)); dec->prev_frame_was_keyframe_ = 0; dec->next_frame_ = 1; } } const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec) { if (dec == NULL) return NULL; return dec->demux_; } void WebPAnimDecoderDelete(WebPAnimDecoder* dec) { if (dec != NULL) { WebPDemuxReleaseIterator(&dec->prev_iter_); WebPDemuxDelete(dec->demux_); WebPSafeFree(dec->curr_frame_); WebPSafeFree(dec->prev_frame_disposed_); WebPSafeFree(dec); } }