�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: demux.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>// Copyright 2012 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.
// -----------------------------------------------------------------------------
//
//  WebP container demux.
//

#ifdef HAVE_CONFIG_H
#include &quot;src/webp/config.h&quot;
#endif

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

#include &quot;src/utils/utils.h&quot;
#include &quot;src/webp/decode.h&quot;  // WebPGetFeatures
#include &quot;src/webp/demux.h&quot;
#include &quot;src/webp/format_constants.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 DMUX_MAJ_VERSION 1
#define DMUX_MIN_VERSION 6
#define DMUX_REV_VERSION 0

typedef struct {
  size_t start;     // start location of the data
  size_t end;       // end location
  size_t riff_end;  // riff chunk end location, can be &gt; end.
  size_t buf_size;  // size of the buffer
  const uint8_t* buf;
} MemBuffer;

typedef struct {
  size_t offset;
  size_t size;
} ChunkData;

typedef struct Frame {
  int x_offset, y_offset;
  int width, height;
  int has_alpha;
  int duration;
  WebPMuxAnimDispose dispose_method;
  WebPMuxAnimBlend blend_method;
  int frame_num;
  int complete;                 // img_components contains a full image.
  ChunkData img_components[2];  // 0=VP8{,L} 1=ALPH
  struct Frame* next;
} Frame;

typedef struct Chunk {
  ChunkData data;
  struct Chunk* next;
} Chunk;

struct WebPDemuxer {
  MemBuffer mem;
  WebPDemuxState state;
  int is_ext_format;
  uint32_t feature_flags;
  int canvas_width, canvas_height;
  int loop_count;
  uint32_t bgcolor;
  int num_frames;
  Frame* frames;
  Frame** frames_tail;
  Chunk* chunks;  // non-image chunks
  Chunk** chunks_tail;
};

typedef enum { PARSE_OK, PARSE_NEED_MORE_DATA, PARSE_ERROR } ParseStatus;

typedef struct ChunkParser {
  uint8_t id[4];
  ParseStatus (*parse)(WebPDemuxer* const dmux);
  int (*valid)(const WebPDemuxer* const dmux);
} ChunkParser;

static ParseStatus ParseSingleImage(WebPDemuxer* const dmux);
static ParseStatus ParseVP8X(WebPDemuxer* const dmux);
static int IsValidSimpleFormat(const WebPDemuxer* const dmux);
static int IsValidExtendedFormat(const WebPDemuxer* const dmux);

static const ChunkParser kMasterChunks[] = {
    {{&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039; &#039;}, ParseSingleImage, IsValidSimpleFormat},
    {{&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039;L&#039;}, ParseSingleImage, IsValidSimpleFormat},
    {{&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039;X&#039;}, ParseVP8X, IsValidExtendedFormat},
    {{&#039;0&#039;, &#039;0&#039;, &#039;0&#039;, &#039;0&#039;}, NULL, NULL},
};

//------------------------------------------------------------------------------

int WebPGetDemuxVersion(void) {
  return (DMUX_MAJ_VERSION &lt;&lt; 16) | (DMUX_MIN_VERSION &lt;&lt; 8) | DMUX_REV_VERSION;
}

// -----------------------------------------------------------------------------
// MemBuffer

static int RemapMemBuffer(MemBuffer* const mem, const uint8_t* data,
                          size_t size) {
  if (size &lt; mem-&gt;buf_size) return 0;  // can&#039;t remap to a shorter buffer!

  mem-&gt;buf = data;
  mem-&gt;end = mem-&gt;buf_size = size;
  return 1;
}

static int InitMemBuffer(MemBuffer* const mem, const uint8_t* data,
                         size_t size) {
  WEBP_UNSAFE_MEMSET(mem, 0, sizeof(*mem));
  return RemapMemBuffer(mem, data, size);
}

// Return the remaining data size available in &#039;mem&#039;.
static WEBP_INLINE size_t MemDataSize(const MemBuffer* const mem) {
  return (mem-&gt;end - mem-&gt;start);
}

// Return true if &#039;size&#039; exceeds the end of the RIFF chunk.
static WEBP_INLINE int SizeIsInvalid(const MemBuffer* const mem, size_t size) {
  return (size &gt; mem-&gt;riff_end - mem-&gt;start);
}

static WEBP_INLINE void Skip(MemBuffer* const mem, size_t size) {
  mem-&gt;start += size;
}

static WEBP_INLINE void Rewind(MemBuffer* const mem, size_t size) {
  mem-&gt;start -= size;
}

static WEBP_INLINE const uint8_t* GetBuffer(MemBuffer* const mem) {
  return mem-&gt;buf + mem-&gt;start;
}

// Read from &#039;mem&#039; and skip the read bytes.
static WEBP_INLINE uint8_t ReadByte(MemBuffer* const mem) {
  const uint8_t byte = mem-&gt;buf[mem-&gt;start];
  Skip(mem, 1);
  return byte;
}

static WEBP_INLINE int ReadLE16s(MemBuffer* const mem) {
  const uint8_t* const data = mem-&gt;buf + mem-&gt;start;
  const int val = GetLE16(data);
  Skip(mem, 2);
  return val;
}

static WEBP_INLINE int ReadLE24s(MemBuffer* const mem) {
  const uint8_t* const data = mem-&gt;buf + mem-&gt;start;
  const int val = GetLE24(data);
  Skip(mem, 3);
  return val;
}

static WEBP_INLINE uint32_t ReadLE32(MemBuffer* const mem) {
  const uint8_t* const data = mem-&gt;buf + mem-&gt;start;
  const uint32_t val = GetLE32(data);
  Skip(mem, 4);
  return val;
}

// -----------------------------------------------------------------------------
// Secondary chunk parsing

static void AddChunk(WebPDemuxer* const dmux, Chunk* const chunk) {
  *dmux-&gt;chunks_tail = chunk;
  chunk-&gt;next = NULL;
  dmux-&gt;chunks_tail = &amp;chunk-&gt;next;
}

// Add a frame to the end of the list, ensuring the last frame is complete.
// Returns true on success, false otherwise.
static int AddFrame(WebPDemuxer* const dmux, Frame* const frame) {
  const Frame* const last_frame = *dmux-&gt;frames_tail;
  if (last_frame != NULL &amp;&amp; !last_frame-&gt;complete) return 0;

  *dmux-&gt;frames_tail = frame;
  frame-&gt;next = NULL;
  dmux-&gt;frames_tail = &amp;frame-&gt;next;
  return 1;
}

static void SetFrameInfo(size_t start_offset, size_t size, int frame_num,
                         int complete,
                         const WebPBitstreamFeatures* const features,
                         Frame* const frame) {
  frame-&gt;img_components[0].offset = start_offset;
  frame-&gt;img_components[0].size = size;
  frame-&gt;width = features-&gt;width;
  frame-&gt;height = features-&gt;height;
  frame-&gt;has_alpha |= features-&gt;has_alpha;
  frame-&gt;frame_num = frame_num;
  frame-&gt;complete = complete;
}

// Store image bearing chunks to &#039;frame&#039;. &#039;min_size&#039; is an optional size
// requirement, it may be zero.
static ParseStatus StoreFrame(int frame_num, uint32_t min_size,
                              MemBuffer* const mem, Frame* const frame) {
  int alpha_chunks = 0;
  int image_chunks = 0;
  int done =
      (MemDataSize(mem) &lt; CHUNK_HEADER_SIZE || MemDataSize(mem) &lt; min_size);
  ParseStatus status = PARSE_OK;

  if (done) return PARSE_NEED_MORE_DATA;

  do {
    const size_t chunk_start_offset = mem-&gt;start;
    const uint32_t fourcc = ReadLE32(mem);
    const uint32_t payload_size = ReadLE32(mem);
    uint32_t payload_size_padded;
    size_t payload_available;
    size_t chunk_size;

    if (payload_size &gt; MAX_CHUNK_PAYLOAD) return PARSE_ERROR;

    payload_size_padded = payload_size + (payload_size &amp; 1);
    payload_available = (payload_size_padded &gt; MemDataSize(mem))
                            ? MemDataSize(mem)
                            : payload_size_padded;
    chunk_size = CHUNK_HEADER_SIZE + payload_available;
    if (SizeIsInvalid(mem, payload_size_padded)) return PARSE_ERROR;
    if (payload_size_padded &gt; MemDataSize(mem)) status = PARSE_NEED_MORE_DATA;

    switch (fourcc) {
      case MKFOURCC(&#039;A&#039;, &#039;L&#039;, &#039;P&#039;, &#039;H&#039;):
        if (alpha_chunks == 0) {
          ++alpha_chunks;
          frame-&gt;img_components[1].offset = chunk_start_offset;
          frame-&gt;img_components[1].size = chunk_size;
          frame-&gt;has_alpha = 1;
          frame-&gt;frame_num = frame_num;
          Skip(mem, payload_available);
        } else {
          goto Done;
        }
        break;
      case MKFOURCC(&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039;L&#039;):
        if (alpha_chunks &gt; 0) return PARSE_ERROR;  // VP8L has its own alpha
        // fall through
      case MKFOURCC(&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039; &#039;):
        if (image_chunks == 0) {
          // Extract the bitstream features, tolerating failures when the data
          // is incomplete.
          WebPBitstreamFeatures features;
          const VP8StatusCode vp8_status = WebPGetFeatures(
              mem-&gt;buf + chunk_start_offset, chunk_size, &amp;features);
          if (status == PARSE_NEED_MORE_DATA &amp;&amp;
              vp8_status == VP8_STATUS_NOT_ENOUGH_DATA) {
            return PARSE_NEED_MORE_DATA;
          } else if (vp8_status != VP8_STATUS_OK) {
            // We have enough data, and yet WebPGetFeatures() failed.
            return PARSE_ERROR;
          }
          ++image_chunks;
          SetFrameInfo(chunk_start_offset, chunk_size, frame_num,
                       status == PARSE_OK, &amp;features, frame);
          Skip(mem, payload_available);
        } else {
          goto Done;
        }
        break;
      Done:
      default:
        // Restore fourcc/size when moving up one level in parsing.
        Rewind(mem, CHUNK_HEADER_SIZE);
        done = 1;
        break;
    }

    if (mem-&gt;start == mem-&gt;riff_end) {
      done = 1;
    } else if (MemDataSize(mem) &lt; CHUNK_HEADER_SIZE) {
      status = PARSE_NEED_MORE_DATA;
    }
  } while (!done &amp;&amp; status == PARSE_OK);

  return status;
}

// Creates a new Frame if &#039;actual_size&#039; is within bounds and &#039;mem&#039; contains
// enough data (&#039;min_size&#039;) to parse the payload.
// Returns PARSE_OK on success with *frame pointing to the new Frame.
// Returns PARSE_NEED_MORE_DATA with insufficient data, PARSE_ERROR otherwise.
static ParseStatus NewFrame(const MemBuffer* const mem, uint32_t min_size,
                            uint32_t actual_size, Frame** frame) {
  if (SizeIsInvalid(mem, min_size)) return PARSE_ERROR;
  if (actual_size &lt; min_size) return PARSE_ERROR;
  if (MemDataSize(mem) &lt; min_size) return PARSE_NEED_MORE_DATA;

  *frame = (Frame*)WebPSafeCalloc(1ULL, sizeof(**frame));
  return (*frame == NULL) ? PARSE_ERROR : PARSE_OK;
}

// Parse a &#039;ANMF&#039; chunk and any image bearing chunks that immediately follow.
// &#039;frame_chunk_size&#039; is the previously validated, padded chunk size.
static ParseStatus ParseAnimationFrame(WebPDemuxer* const dmux,
                                       uint32_t frame_chunk_size) {
  const int is_animation = !!(dmux-&gt;feature_flags &amp; ANIMATION_FLAG);
  int added_frame = 0;
  int bits;
  MemBuffer* const mem = &amp;dmux-&gt;mem;
  Frame* frame;
  size_t start_offset;
  ParseStatus status = NewFrame(mem, ANMF_CHUNK_SIZE, frame_chunk_size, &amp;frame);
  if (status != PARSE_OK) return status;

  frame-&gt;x_offset = 2 * ReadLE24s(mem);
  frame-&gt;y_offset = 2 * ReadLE24s(mem);
  frame-&gt;width = 1 + ReadLE24s(mem);
  frame-&gt;height = 1 + ReadLE24s(mem);
  frame-&gt;duration = ReadLE24s(mem);
  bits = ReadByte(mem);
  frame-&gt;dispose_method =
      (bits &amp; 1) ? WEBP_MUX_DISPOSE_BACKGROUND : WEBP_MUX_DISPOSE_NONE;
  frame-&gt;blend_method = (bits &amp; 2) ? WEBP_MUX_NO_BLEND : WEBP_MUX_BLEND;
  if (frame-&gt;width * (uint64_t)frame-&gt;height &gt;= MAX_IMAGE_AREA) {
    WebPSafeFree(frame);
    return PARSE_ERROR;
  }

  // Store a frame only if the animation flag is set there is some data for
  // this frame is available.
  start_offset = mem-&gt;start;
  {
    const uint32_t anmf_payload_size = frame_chunk_size - ANMF_CHUNK_SIZE;
    status = StoreFrame(dmux-&gt;num_frames + 1, anmf_payload_size, mem, frame);
    if (status != PARSE_ERROR &amp;&amp;
        mem-&gt;start - start_offset &gt; anmf_payload_size) {
      status = PARSE_ERROR;
    }
  }
  if (status != PARSE_ERROR &amp;&amp; is_animation &amp;&amp; frame-&gt;frame_num &gt; 0) {
    added_frame = AddFrame(dmux, frame);
    if (added_frame) {
      ++dmux-&gt;num_frames;
    } else {
      status = PARSE_ERROR;
    }
  }

  if (!added_frame) WebPSafeFree(frame);
  return status;
}

// General chunk storage, starting with the header at &#039;start_offset&#039;, allowing
// the user to request the payload via a fourcc string. &#039;size&#039; includes the
// header and the unpadded payload size.
// Returns true on success, false otherwise.
static int StoreChunk(WebPDemuxer* const dmux, size_t start_offset,
                      uint32_t size) {
  Chunk* const chunk = (Chunk*)WebPSafeCalloc(1ULL, sizeof(*chunk));
  if (chunk == NULL) return 0;

  chunk-&gt;data.offset = start_offset;
  chunk-&gt;data.size = size;
  AddChunk(dmux, chunk);
  return 1;
}

// -----------------------------------------------------------------------------
// Primary chunk parsing

static ParseStatus ReadHeader(MemBuffer* const mem) {
  const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;
  uint32_t riff_size;

  // Basic file level validation.
  if (MemDataSize(mem) &lt; min_size) return PARSE_NEED_MORE_DATA;
  if (memcmp(GetBuffer(mem), &quot;RIFF&quot;, CHUNK_SIZE_BYTES) ||
      memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, &quot;WEBP&quot;, CHUNK_SIZE_BYTES)) {
    return PARSE_ERROR;
  }

  riff_size = GetLE32(GetBuffer(mem) + TAG_SIZE);
  if (riff_size &lt; CHUNK_HEADER_SIZE) return PARSE_ERROR;
  if (riff_size &gt; MAX_CHUNK_PAYLOAD) return PARSE_ERROR;

  // There&#039;s no point in reading past the end of the RIFF chunk
  mem-&gt;riff_end = riff_size + CHUNK_HEADER_SIZE;
  if (mem-&gt;buf_size &gt; mem-&gt;riff_end) {
    mem-&gt;buf_size = mem-&gt;end = mem-&gt;riff_end;
  }

  Skip(mem, RIFF_HEADER_SIZE);
  return PARSE_OK;
}

static ParseStatus ParseSingleImage(WebPDemuxer* const dmux) {
  const size_t min_size = CHUNK_HEADER_SIZE;
  MemBuffer* const mem = &amp;dmux-&gt;mem;
  Frame* frame;
  ParseStatus status;
  int image_added = 0;

  if (dmux-&gt;frames != NULL) return PARSE_ERROR;
  if (SizeIsInvalid(mem, min_size)) return PARSE_ERROR;
  if (MemDataSize(mem) &lt; min_size) return PARSE_NEED_MORE_DATA;

  frame = (Frame*)WebPSafeCalloc(1ULL, sizeof(*frame));
  if (frame == NULL) return PARSE_ERROR;

  // For the single image case we allow parsing of a partial frame, so no
  // minimum size is imposed here.
  status = StoreFrame(1, 0, &amp;dmux-&gt;mem, frame);
  if (status != PARSE_ERROR) {
    const int has_alpha = !!(dmux-&gt;feature_flags &amp; ALPHA_FLAG);
    // Clear any alpha when the alpha flag is missing.
    if (!has_alpha &amp;&amp; frame-&gt;img_components[1].size &gt; 0) {
      frame-&gt;img_components[1].offset = 0;
      frame-&gt;img_components[1].size = 0;
      frame-&gt;has_alpha = 0;
    }

    // Use the frame width/height as the canvas values for non-vp8x files.
    // Also, set ALPHA_FLAG if this is a lossless image with alpha.
    if (!dmux-&gt;is_ext_format &amp;&amp; frame-&gt;width &gt; 0 &amp;&amp; frame-&gt;height &gt; 0) {
      dmux-&gt;state = WEBP_DEMUX_PARSED_HEADER;
      dmux-&gt;canvas_width = frame-&gt;width;
      dmux-&gt;canvas_height = frame-&gt;height;
      dmux-&gt;feature_flags |= frame-&gt;has_alpha ? ALPHA_FLAG : 0;
    }
    if (!AddFrame(dmux, frame)) {
      status = PARSE_ERROR;  // last frame was left incomplete
    } else {
      image_added = 1;
      dmux-&gt;num_frames = 1;
    }
  }

  if (!image_added) WebPSafeFree(frame);
  return status;
}

static ParseStatus ParseVP8XChunks(WebPDemuxer* const dmux) {
  const int is_animation = !!(dmux-&gt;feature_flags &amp; ANIMATION_FLAG);
  MemBuffer* const mem = &amp;dmux-&gt;mem;
  int anim_chunks = 0;
  ParseStatus status = PARSE_OK;

  do {
    int store_chunk = 1;
    const size_t chunk_start_offset = mem-&gt;start;
    const uint32_t fourcc = ReadLE32(mem);
    const uint32_t chunk_size = ReadLE32(mem);
    uint32_t chunk_size_padded;

    if (chunk_size &gt; MAX_CHUNK_PAYLOAD) return PARSE_ERROR;

    chunk_size_padded = chunk_size + (chunk_size &amp; 1);
    if (SizeIsInvalid(mem, chunk_size_padded)) return PARSE_ERROR;

    switch (fourcc) {
      case MKFOURCC(&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039;X&#039;): {
        return PARSE_ERROR;
      }
      case MKFOURCC(&#039;A&#039;, &#039;L&#039;, &#039;P&#039;, &#039;H&#039;):
      case MKFOURCC(&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039; &#039;):
      case MKFOURCC(&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039;L&#039;): {
        // check that this isn&#039;t an animation (all frames should be in an ANMF).
        if (anim_chunks &gt; 0 || is_animation) return PARSE_ERROR;

        Rewind(mem, CHUNK_HEADER_SIZE);
        status = ParseSingleImage(dmux);
        break;
      }
      case MKFOURCC(&#039;A&#039;, &#039;N&#039;, &#039;I&#039;, &#039;M&#039;): {
        if (chunk_size_padded &lt; ANIM_CHUNK_SIZE) return PARSE_ERROR;

        if (MemDataSize(mem) &lt; chunk_size_padded) {
          status = PARSE_NEED_MORE_DATA;
        } else if (anim_chunks == 0) {
          ++anim_chunks;
          dmux-&gt;bgcolor = ReadLE32(mem);
          dmux-&gt;loop_count = ReadLE16s(mem);
          Skip(mem, chunk_size_padded - ANIM_CHUNK_SIZE);
        } else {
          store_chunk = 0;
          goto Skip;
        }
        break;
      }
      case MKFOURCC(&#039;A&#039;, &#039;N&#039;, &#039;M&#039;, &#039;F&#039;): {
        if (anim_chunks == 0) return PARSE_ERROR;  // &#039;ANIM&#039; precedes frames.
        status = ParseAnimationFrame(dmux, chunk_size_padded);
        break;
      }
      case MKFOURCC(&#039;I&#039;, &#039;C&#039;, &#039;C&#039;, &#039;P&#039;): {
        store_chunk = !!(dmux-&gt;feature_flags &amp; ICCP_FLAG);
        goto Skip;
      }
      case MKFOURCC(&#039;E&#039;, &#039;X&#039;, &#039;I&#039;, &#039;F&#039;): {
        store_chunk = !!(dmux-&gt;feature_flags &amp; EXIF_FLAG);
        goto Skip;
      }
      case MKFOURCC(&#039;X&#039;, &#039;M&#039;, &#039;P&#039;, &#039; &#039;): {
        store_chunk = !!(dmux-&gt;feature_flags &amp; XMP_FLAG);
        goto Skip;
      }
      Skip:
      default: {
        if (chunk_size_padded &lt;= MemDataSize(mem)) {
          if (store_chunk) {
            // Store only the chunk header and unpadded size as only the payload
            // will be returned to the user.
            if (!StoreChunk(dmux, chunk_start_offset,
                            CHUNK_HEADER_SIZE + chunk_size)) {
              return PARSE_ERROR;
            }
          }
          Skip(mem, chunk_size_padded);
        } else {
          status = PARSE_NEED_MORE_DATA;
        }
      }
    }

    if (mem-&gt;start == mem-&gt;riff_end) {
      break;
    } else if (MemDataSize(mem) &lt; CHUNK_HEADER_SIZE) {
      status = PARSE_NEED_MORE_DATA;
    }
  } while (status == PARSE_OK);

  return status;
}

static ParseStatus ParseVP8X(WebPDemuxer* const dmux) {
  MemBuffer* const mem = &amp;dmux-&gt;mem;
  uint32_t vp8x_size;

  if (MemDataSize(mem) &lt; CHUNK_HEADER_SIZE) return PARSE_NEED_MORE_DATA;

  dmux-&gt;is_ext_format = 1;
  Skip(mem, TAG_SIZE);  // VP8X
  vp8x_size = ReadLE32(mem);
  if (vp8x_size &gt; MAX_CHUNK_PAYLOAD) return PARSE_ERROR;
  if (vp8x_size &lt; VP8X_CHUNK_SIZE) return PARSE_ERROR;
  vp8x_size += vp8x_size &amp; 1;
  if (SizeIsInvalid(mem, vp8x_size)) return PARSE_ERROR;
  if (MemDataSize(mem) &lt; vp8x_size) return PARSE_NEED_MORE_DATA;

  dmux-&gt;feature_flags = ReadByte(mem);
  Skip(mem, 3);  // Reserved.
  dmux-&gt;canvas_width = 1 + ReadLE24s(mem);
  dmux-&gt;canvas_height = 1 + ReadLE24s(mem);
  if (dmux-&gt;canvas_width * (uint64_t)dmux-&gt;canvas_height &gt;= MAX_IMAGE_AREA) {
    return PARSE_ERROR;  // image final dimension is too large
  }
  Skip(mem, vp8x_size - VP8X_CHUNK_SIZE);  // skip any trailing data.
  dmux-&gt;state = WEBP_DEMUX_PARSED_HEADER;

  if (SizeIsInvalid(mem, CHUNK_HEADER_SIZE)) return PARSE_ERROR;
  if (MemDataSize(mem) &lt; CHUNK_HEADER_SIZE) return PARSE_NEED_MORE_DATA;

  return ParseVP8XChunks(dmux);
}

// -----------------------------------------------------------------------------
// Format validation

static int IsValidSimpleFormat(const WebPDemuxer* const dmux) {
  const Frame* const frame = dmux-&gt;frames;
  if (dmux-&gt;state == WEBP_DEMUX_PARSING_HEADER) return 1;

  if (dmux-&gt;canvas_width &lt;= 0 || dmux-&gt;canvas_height &lt;= 0) return 0;
  if (dmux-&gt;state == WEBP_DEMUX_DONE &amp;&amp; frame == NULL) return 0;

  if (frame-&gt;width &lt;= 0 || frame-&gt;height &lt;= 0) return 0;
  return 1;
}

// If &#039;exact&#039; is true, check that the image resolution matches the canvas.
// If &#039;exact&#039; is false, check that the x/y offsets do not exceed the canvas.
static int CheckFrameBounds(const Frame* const frame, int exact,
                            int canvas_width, int canvas_height) {
  if (exact) {
    if (frame-&gt;x_offset != 0 || frame-&gt;y_offset != 0) {
      return 0;
    }
    if (frame-&gt;width != canvas_width || frame-&gt;height != canvas_height) {
      return 0;
    }
  } else {
    if (frame-&gt;x_offset &lt; 0 || frame-&gt;y_offset &lt; 0) return 0;
    if (frame-&gt;width + frame-&gt;x_offset &gt; canvas_width) return 0;
    if (frame-&gt;height + frame-&gt;y_offset &gt; canvas_height) return 0;
  }
  return 1;
}

static int IsValidExtendedFormat(const WebPDemuxer* const dmux) {
  const int is_animation = !!(dmux-&gt;feature_flags &amp; ANIMATION_FLAG);
  const Frame* f = dmux-&gt;frames;

  if (dmux-&gt;state == WEBP_DEMUX_PARSING_HEADER) return 1;

  if (dmux-&gt;canvas_width &lt;= 0 || dmux-&gt;canvas_height &lt;= 0) return 0;
  if (dmux-&gt;loop_count &lt; 0) return 0;
  if (dmux-&gt;state == WEBP_DEMUX_DONE &amp;&amp; dmux-&gt;frames == NULL) return 0;
  if (dmux-&gt;feature_flags &amp; ~ALL_VALID_FLAGS) return 0;  // invalid bitstream

  while (f != NULL) {
    const int cur_frame_set = f-&gt;frame_num;

    // Check frame properties.
    for (; f != NULL &amp;&amp; f-&gt;frame_num == cur_frame_set; f = f-&gt;next) {
      const ChunkData* const image = f-&gt;img_components;
      const ChunkData* const alpha = f-&gt;img_components + 1;

      if (!is_animation &amp;&amp; f-&gt;frame_num &gt; 1) return 0;

      if (f-&gt;complete) {
        if (alpha-&gt;size == 0 &amp;&amp; image-&gt;size == 0) return 0;
        // Ensure alpha precedes image bitstream.
        if (alpha-&gt;size &gt; 0 &amp;&amp; alpha-&gt;offset &gt; image-&gt;offset) {
          return 0;
        }

        if (f-&gt;width &lt;= 0 || f-&gt;height &lt;= 0) return 0;
      } else {
        // There shouldn&#039;t be a partial frame in a complete file.
        if (dmux-&gt;state == WEBP_DEMUX_DONE) return 0;

        // Ensure alpha precedes image bitstream.
        if (alpha-&gt;size &gt; 0 &amp;&amp; image-&gt;size &gt; 0 &amp;&amp;
            alpha-&gt;offset &gt; image-&gt;offset) {
          return 0;
        }
        // There shouldn&#039;t be any frames after an incomplete one.
        if (f-&gt;next != NULL) return 0;
      }

      if (f-&gt;width &gt; 0 &amp;&amp; f-&gt;height &gt; 0 &amp;&amp;
          !CheckFrameBounds(f, !is_animation, dmux-&gt;canvas_width,
                            dmux-&gt;canvas_height)) {
        return 0;
      }
    }
  }
  return 1;
}

// -----------------------------------------------------------------------------
// WebPDemuxer object

static void InitDemux(WebPDemuxer* const dmux, const MemBuffer* const mem) {
  dmux-&gt;state = WEBP_DEMUX_PARSING_HEADER;
  dmux-&gt;loop_count = 1;
  dmux-&gt;bgcolor = 0xFFFFFFFF;  // White background by default.
  dmux-&gt;canvas_width = -1;
  dmux-&gt;canvas_height = -1;
  dmux-&gt;frames_tail = &amp;dmux-&gt;frames;
  dmux-&gt;chunks_tail = &amp;dmux-&gt;chunks;
  dmux-&gt;mem = *mem;
}

static ParseStatus CreateRawImageDemuxer(MemBuffer* const mem,
                                         WebPDemuxer** demuxer) {
  WebPBitstreamFeatures features;
  const VP8StatusCode status =
      WebPGetFeatures(mem-&gt;buf, mem-&gt;buf_size, &amp;features);
  *demuxer = NULL;
  if (status != VP8_STATUS_OK) {
    return (status == VP8_STATUS_NOT_ENOUGH_DATA) ? PARSE_NEED_MORE_DATA
                                                  : PARSE_ERROR;
  }

  {
    WebPDemuxer* const dmux = (WebPDemuxer*)WebPSafeCalloc(1ULL, sizeof(*dmux));
    Frame* const frame = (Frame*)WebPSafeCalloc(1ULL, sizeof(*frame));
    if (dmux == NULL || frame == NULL) goto Error;
    InitDemux(dmux, mem);
    SetFrameInfo(0, mem-&gt;buf_size, 1 /*frame_num*/, 1 /*complete*/, &amp;features,
                 frame);
    if (!AddFrame(dmux, frame)) goto Error;
    dmux-&gt;state = WEBP_DEMUX_DONE;
    dmux-&gt;canvas_width = frame-&gt;width;
    dmux-&gt;canvas_height = frame-&gt;height;
    dmux-&gt;feature_flags |= frame-&gt;has_alpha ? ALPHA_FLAG : 0;
    dmux-&gt;num_frames = 1;
    assert(IsValidSimpleFormat(dmux));
    *demuxer = dmux;
    return PARSE_OK;

  Error:
    WebPSafeFree(dmux);
    WebPSafeFree(frame);
    return PARSE_ERROR;
  }
}

WebPDemuxer* WebPDemuxInternal(const WebPData* data, int allow_partial,
                               WebPDemuxState* state, int version) {
  const ChunkParser* parser;
  int partial;
  ParseStatus status = PARSE_ERROR;
  MemBuffer mem;
  WebPDemuxer* dmux;

  if (state != NULL) *state = WEBP_DEMUX_PARSE_ERROR;

  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DEMUX_ABI_VERSION)) return NULL;
  if (data == NULL || data-&gt;bytes == NULL || data-&gt;size == 0) return NULL;

  if (!InitMemBuffer(&amp;mem, data-&gt;bytes, data-&gt;size)) return NULL;
  status = ReadHeader(&amp;mem);
  if (status != PARSE_OK) {
    // If parsing of the webp file header fails attempt to handle a raw
    // VP8/VP8L frame. Note &#039;allow_partial&#039; is ignored in this case.
    if (status == PARSE_ERROR) {
      status = CreateRawImageDemuxer(&amp;mem, &amp;dmux);
      if (status == PARSE_OK) {
        if (state != NULL) *state = WEBP_DEMUX_DONE;
        return dmux;
      }
    }
    if (state != NULL) {
      *state = (status == PARSE_NEED_MORE_DATA) ? WEBP_DEMUX_PARSING_HEADER
                                                : WEBP_DEMUX_PARSE_ERROR;
    }
    return NULL;
  }

  partial = (mem.buf_size &lt; mem.riff_end);
  if (!allow_partial &amp;&amp; partial) return NULL;

  dmux = (WebPDemuxer*)WebPSafeCalloc(1ULL, sizeof(*dmux));
  if (dmux == NULL) return NULL;
  InitDemux(dmux, &amp;mem);

  status = PARSE_ERROR;
  for (parser = kMasterChunks; parser-&gt;parse != NULL; ++parser) {
    if (!memcmp(parser-&gt;id, GetBuffer(&amp;dmux-&gt;mem), TAG_SIZE)) {
      status = parser-&gt;parse(dmux);
      if (status == PARSE_OK) dmux-&gt;state = WEBP_DEMUX_DONE;
      if (status == PARSE_NEED_MORE_DATA &amp;&amp; !partial) status = PARSE_ERROR;
      if (status != PARSE_ERROR &amp;&amp; !parser-&gt;valid(dmux)) status = PARSE_ERROR;
      if (status == PARSE_ERROR) dmux-&gt;state = WEBP_DEMUX_PARSE_ERROR;
      break;
    }
  }
  if (state != NULL) *state = dmux-&gt;state;

  if (status == PARSE_ERROR) {
    WebPDemuxDelete(dmux);
    return NULL;
  }
  return dmux;
}

void WebPDemuxDelete(WebPDemuxer* dmux) {
  Chunk* c;
  Frame* f;
  if (dmux == NULL) return;

  for (f = dmux-&gt;frames; f != NULL;) {
    Frame* const cur_frame = f;
    f = f-&gt;next;
    WebPSafeFree(cur_frame);
  }
  for (c = dmux-&gt;chunks; c != NULL;) {
    Chunk* const cur_chunk = c;
    c = c-&gt;next;
    WebPSafeFree(cur_chunk);
  }
  WebPSafeFree(dmux);
}

// -----------------------------------------------------------------------------

uint32_t WebPDemuxGetI(const WebPDemuxer* dmux, WebPFormatFeature feature) {
  if (dmux == NULL) return 0;

  switch (feature) {
    case WEBP_FF_FORMAT_FLAGS:
      return dmux-&gt;feature_flags;
    case WEBP_FF_CANVAS_WIDTH:
      return (uint32_t)dmux-&gt;canvas_width;
    case WEBP_FF_CANVAS_HEIGHT:
      return (uint32_t)dmux-&gt;canvas_height;
    case WEBP_FF_LOOP_COUNT:
      return (uint32_t)dmux-&gt;loop_count;
    case WEBP_FF_BACKGROUND_COLOR:
      return dmux-&gt;bgcolor;
    case WEBP_FF_FRAME_COUNT:
      return (uint32_t)dmux-&gt;num_frames;
  }
  return 0;
}

// -----------------------------------------------------------------------------
// Frame iteration

static const Frame* GetFrame(const WebPDemuxer* const dmux, int frame_num) {
  const Frame* f;
  for (f = dmux-&gt;frames; f != NULL; f = f-&gt;next) {
    if (frame_num == f-&gt;frame_num) break;
  }
  return f;
}

static const uint8_t* GetFramePayload(const uint8_t* const mem_buf,
                                      const Frame* const frame,
                                      size_t* const data_size) {
  *data_size = 0;
  if (frame != NULL) {
    const ChunkData* const image = frame-&gt;img_components;
    const ChunkData* const alpha = frame-&gt;img_components + 1;
    size_t start_offset = image-&gt;offset;
    *data_size = image-&gt;size;

    // if alpha exists it precedes image, update the size allowing for
    // intervening chunks.
    if (alpha-&gt;size &gt; 0) {
      const size_t inter_size =
          (image-&gt;offset &gt; 0) ? image-&gt;offset - (alpha-&gt;offset + alpha-&gt;size)
                              : 0;
      start_offset = alpha-&gt;offset;
      *data_size += alpha-&gt;size + inter_size;
    }
    return mem_buf + start_offset;
  }
  return NULL;
}

// Create a whole &#039;frame&#039; from VP8 (+ alpha) or lossless.
static int SynthesizeFrame(const WebPDemuxer* const dmux,
                           const Frame* const frame, WebPIterator* const iter) {
  const uint8_t* const mem_buf = dmux-&gt;mem.buf;
  size_t payload_size = 0;
  const uint8_t* const payload = GetFramePayload(mem_buf, frame, &amp;payload_size);
  if (payload == NULL) return 0;
  assert(frame != NULL);

  iter-&gt;frame_num = frame-&gt;frame_num;
  iter-&gt;num_frames = dmux-&gt;num_frames;
  iter-&gt;x_offset = frame-&gt;x_offset;
  iter-&gt;y_offset = frame-&gt;y_offset;
  iter-&gt;width = frame-&gt;width;
  iter-&gt;height = frame-&gt;height;
  iter-&gt;has_alpha = frame-&gt;has_alpha;
  iter-&gt;duration = frame-&gt;duration;
  iter-&gt;dispose_method = frame-&gt;dispose_method;
  iter-&gt;blend_method = frame-&gt;blend_method;
  iter-&gt;complete = frame-&gt;complete;
  iter-&gt;fragment.bytes = payload;
  iter-&gt;fragment.size = payload_size;
  return 1;
}

static int SetFrame(int frame_num, WebPIterator* const iter) {
  const Frame* frame;
  const WebPDemuxer* const dmux = (WebPDemuxer*)iter-&gt;private_;
  if (dmux == NULL || frame_num &lt; 0) return 0;
  if (frame_num &gt; dmux-&gt;num_frames) return 0;
  if (frame_num == 0) frame_num = dmux-&gt;num_frames;

  frame = GetFrame(dmux, frame_num);
  if (frame == NULL) return 0;

  return SynthesizeFrame(dmux, frame, iter);
}

int WebPDemuxGetFrame(const WebPDemuxer* dmux, int frame, WebPIterator* iter) {
  if (iter == NULL) return 0;

  WEBP_UNSAFE_MEMSET(iter, 0, sizeof(*iter));
  iter-&gt;private_ = (void*)dmux;
  return SetFrame(frame, iter);
}

int WebPDemuxNextFrame(WebPIterator* iter) {
  if (iter == NULL) return 0;
  return SetFrame(iter-&gt;frame_num + 1, iter);
}

int WebPDemuxPrevFrame(WebPIterator* iter) {
  if (iter == NULL) return 0;
  if (iter-&gt;frame_num &lt;= 1) return 0;
  return SetFrame(iter-&gt;frame_num - 1, iter);
}

void WebPDemuxReleaseIterator(WebPIterator* iter) { (void)iter; }

// -----------------------------------------------------------------------------
// Chunk iteration

static int ChunkCount(const WebPDemuxer* const dmux, const char fourcc[4]) {
  const uint8_t* const mem_buf = dmux-&gt;mem.buf;
  const Chunk* c;
  int count = 0;
  for (c = dmux-&gt;chunks; c != NULL; c = c-&gt;next) {
    const uint8_t* const header = mem_buf + c-&gt;data.offset;
    if (!memcmp(header, fourcc, TAG_SIZE)) ++count;
  }
  return count;
}

static const Chunk* GetChunk(const WebPDemuxer* const dmux,
                             const char fourcc[4], int chunk_num) {
  const uint8_t* const mem_buf = dmux-&gt;mem.buf;
  const Chunk* c;
  int count = 0;
  for (c = dmux-&gt;chunks; c != NULL; c = c-&gt;next) {
    const uint8_t* const header = mem_buf + c-&gt;data.offset;
    if (!memcmp(header, fourcc, TAG_SIZE)) ++count;
    if (count == chunk_num) break;
  }
  return c;
}

static int SetChunk(const char fourcc[4], int chunk_num,
                    WebPChunkIterator* const iter) {
  const WebPDemuxer* const dmux = (WebPDemuxer*)iter-&gt;private_;
  int count;

  if (dmux == NULL || fourcc == NULL || chunk_num &lt; 0) return 0;
  count = ChunkCount(dmux, fourcc);
  if (count == 0) return 0;
  if (chunk_num == 0) chunk_num = count;

  if (chunk_num &lt;= count) {
    const uint8_t* const mem_buf = dmux-&gt;mem.buf;
    const Chunk* const chunk = GetChunk(dmux, fourcc, chunk_num);
    iter-&gt;chunk.bytes = mem_buf + chunk-&gt;data.offset + CHUNK_HEADER_SIZE;
    iter-&gt;chunk.size = chunk-&gt;data.size - CHUNK_HEADER_SIZE;
    iter-&gt;num_chunks = count;
    iter-&gt;chunk_num = chunk_num;
    return 1;
  }
  return 0;
}

int WebPDemuxGetChunk(const WebPDemuxer* dmux, const char fourcc[4],
                      int chunk_num, WebPChunkIterator* iter) {
  if (iter == NULL) return 0;

  WEBP_UNSAFE_MEMSET(iter, 0, sizeof(*iter));
  iter-&gt;private_ = (void*)dmux;
  return SetChunk(fourcc, chunk_num, iter);
}

int WebPDemuxNextChunk(WebPChunkIterator* iter) {
  if (iter != NULL) {
    const char* const fourcc =
        (const char*)iter-&gt;chunk.bytes - CHUNK_HEADER_SIZE;
    return SetChunk(fourcc, iter-&gt;chunk_num + 1, iter);
  }
  return 0;
}

int WebPDemuxPrevChunk(WebPChunkIterator* iter) {
  if (iter != NULL &amp;&amp; iter-&gt;chunk_num &gt; 1) {
    const char* const fourcc =
        (const char*)iter-&gt;chunk.bytes - CHUNK_HEADER_SIZE;
    return SetChunk(fourcc, iter-&gt;chunk_num - 1, iter);
  }
  return 0;
}

void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter) { (void)iter; }
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fsrc%2Fdemux'>🔙 Back</a></p>