�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%2Fexamples%2F'>examples</a>/</p><hr><h3>✏️ Editing: webpinfo.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>// Copyright 2017 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.
// -----------------------------------------------------------------------------
//
//  Command-line tool to print out the chunk level structure of WebP files
//  along with basic integrity checks.
//
//  Author: Hui Su (huisu@google.com)

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

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

#include &quot;../imageio/imageio_util.h&quot;
#include &quot;./unicode.h&quot;
#include &quot;webp/decode.h&quot;
#include &quot;webp/format_constants.h&quot;
#include &quot;webp/mux_types.h&quot;
#include &quot;webp/types.h&quot;

#if defined(_MSC_VER) &amp;&amp; _MSC_VER &lt; 1900
#define snprintf _snprintf
#endif

#define LOG_ERROR(MESSAGE)                     \
  do {                                         \
    if (webp_info-&gt;show_diagnosis) {           \
      fprintf(stderr, &quot;Error: %s\n&quot;, MESSAGE); \
    }                                          \
  } while (0)

#define LOG_WARN(MESSAGE)                        \
  do {                                           \
    if (webp_info-&gt;show_diagnosis) {             \
      fprintf(stderr, &quot;Warning: %s\n&quot;, MESSAGE); \
    }                                            \
    ++webp_info-&gt;num_warnings;                   \
  } while (0)

static const char* const kFormats[3] = {&quot;Unknown&quot;, &quot;Lossy&quot;, &quot;Lossless&quot;};

static const char* const kLosslessTransforms[4] = {
    &quot;Predictor&quot;, &quot;Cross Color&quot;, &quot;Subtract Green&quot;, &quot;Color Indexing&quot;};

static const char* const kAlphaFilterMethods[4] = {&quot;None&quot;, &quot;Horizontal&quot;,
                                                   &quot;Vertical&quot;, &quot;Gradient&quot;};

typedef enum {
  WEBP_INFO_OK = 0,
  WEBP_INFO_TRUNCATED_DATA,
  WEBP_INFO_PARSE_ERROR,
  WEBP_INFO_INVALID_PARAM,
  WEBP_INFO_BITSTREAM_ERROR,
  WEBP_INFO_MISSING_DATA,
  WEBP_INFO_INVALID_COMMAND
} WebPInfoStatus;

typedef enum ChunkID {
  CHUNK_VP8,
  CHUNK_VP8L,
  CHUNK_VP8X,
  CHUNK_ALPHA,
  CHUNK_ANIM,
  CHUNK_ANMF,
  CHUNK_ICCP,
  CHUNK_EXIF,
  CHUNK_XMP,
  CHUNK_UNKNOWN,
  CHUNK_TYPES = CHUNK_UNKNOWN
} ChunkID;

typedef struct {
  size_t start;
  size_t end;
  const uint8_t* buf;
} MemBuffer;

typedef struct {
  size_t offset;
  size_t size;
  const uint8_t* payload;
  ChunkID id;
} ChunkData;

typedef struct WebPInfo {
  int canvas_width;
  int canvas_height;
  int loop_count;
  int num_frames;
  int chunk_counts[CHUNK_TYPES];
  int anmf_subchunk_counts[3];  // 0 VP8; 1 VP8L; 2 ALPH.
  uint32_t bgcolor;
  int feature_flags;
  int has_alpha;
  // Used for parsing ANMF chunks.
  int frame_width, frame_height;
  size_t anim_frame_data_size;
  int is_processing_anim_frame, seen_alpha_subchunk, seen_image_subchunk;
  // Print output control.
  int quiet, show_diagnosis, show_summary;
  int num_warnings;
  int parse_bitstream;
} WebPInfo;

static void WebPInfoInit(WebPInfo* const webp_info) {
  memset(webp_info, 0, sizeof(*webp_info));
}

static const uint32_t kWebPChunkTags[CHUNK_TYPES] = {
    MKFOURCC(&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039; &#039;),  //
    MKFOURCC(&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039;L&#039;),  //
    MKFOURCC(&#039;V&#039;, &#039;P&#039;, &#039;8&#039;, &#039;X&#039;),  //
    MKFOURCC(&#039;A&#039;, &#039;L&#039;, &#039;P&#039;, &#039;H&#039;),  //
    MKFOURCC(&#039;A&#039;, &#039;N&#039;, &#039;I&#039;, &#039;M&#039;),  //
    MKFOURCC(&#039;A&#039;, &#039;N&#039;, &#039;M&#039;, &#039;F&#039;),  //
    MKFOURCC(&#039;I&#039;, &#039;C&#039;, &#039;C&#039;, &#039;P&#039;),  //
    MKFOURCC(&#039;E&#039;, &#039;X&#039;, &#039;I&#039;, &#039;F&#039;),  //
    MKFOURCC(&#039;X&#039;, &#039;M&#039;, &#039;P&#039;, &#039; &#039;),  //
};

// -----------------------------------------------------------------------------
// Data reading.

static int GetLE16(const uint8_t* const data) {
  return (data[0] &lt;&lt; 0) | (data[1] &lt;&lt; 8);
}

static int GetLE24(const uint8_t* const data) {
  return GetLE16(data) | (data[2] &lt;&lt; 16);
}

static uint32_t GetLE32(const uint8_t* const data) {
  return GetLE16(data) | ((uint32_t)GetLE16(data + 2) &lt;&lt; 16);
}

static int ReadLE16(const uint8_t** data) {
  const int val = GetLE16(*data);
  *data += 2;
  return val;
}

static int ReadLE24(const uint8_t** data) {
  const int val = GetLE24(*data);
  *data += 3;
  return val;
}

static uint32_t ReadLE32(const uint8_t** data) {
  const uint32_t val = GetLE32(*data);
  *data += 4;
  return val;
}

static int ReadFileToWebPData(const char* const filename,
                              WebPData* const webp_data) {
  const uint8_t* data;
  size_t size;
  if (!ImgIoUtilReadFile(filename, &amp;data, &amp;size)) return 0;
  webp_data-&gt;bytes = data;
  webp_data-&gt;size = size;
  return 1;
}

// -----------------------------------------------------------------------------
// MemBuffer object.

static void InitMemBuffer(MemBuffer* const mem, const WebPData* webp_data) {
  mem-&gt;buf = webp_data-&gt;bytes;
  mem-&gt;start = 0;
  mem-&gt;end = webp_data-&gt;size;
}

static size_t MemDataSize(const MemBuffer* const mem) {
  return (mem-&gt;end - mem-&gt;start);
}

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

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

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

// -----------------------------------------------------------------------------
// Lossy bitstream analysis.

static int GetBits(const uint8_t* const data, size_t data_size, size_t nb,
                   int* val, uint64_t* const bit_pos) {
  *val = 0;
  while (nb-- &gt; 0) {
    const uint64_t p = (*bit_pos)++;
    if ((p &gt;&gt; 3) &gt;= data_size) {
      return 0;
    } else {
      const int bit = !!(data[p &gt;&gt; 3] &amp; (128 &gt;&gt; ((p &amp; 7))));
      *val = (*val &lt;&lt; 1) | bit;
    }
  }
  return 1;
}

static int GetSignedBits(const uint8_t* const data, size_t data_size, size_t nb,
                         int* val, uint64_t* const bit_pos) {
  int sign;
  if (!GetBits(data, data_size, nb, val, bit_pos)) return 0;
  if (!GetBits(data, data_size, 1, &amp;sign, bit_pos)) return 0;
  if (sign) *val = -(*val);
  return 1;
}

#define GET_BITS(v, n)                                 \
  do {                                                 \
    if (!GetBits(data, data_size, n, &amp;(v), bit_pos)) { \
      LOG_ERROR(&quot;Truncated lossy bitstream.&quot;);         \
      return WEBP_INFO_TRUNCATED_DATA;                 \
    }                                                  \
  } while (0)

#define GET_SIGNED_BITS(v, n)                                \
  do {                                                       \
    if (!GetSignedBits(data, data_size, n, &amp;(v), bit_pos)) { \
      LOG_ERROR(&quot;Truncated lossy bitstream.&quot;);               \
      return WEBP_INFO_TRUNCATED_DATA;                       \
    }                                                        \
  } while (0)

static WebPInfoStatus ParseLossySegmentHeader(const WebPInfo* const webp_info,
                                              const uint8_t* const data,
                                              size_t data_size,
                                              uint64_t* const bit_pos) {
  int use_segment;
  GET_BITS(use_segment, 1);
  printf(&quot;  Use segment:      %d\n&quot;, use_segment);
  if (use_segment) {
    int update_map, update_data;
    GET_BITS(update_map, 1);
    GET_BITS(update_data, 1);
    printf(
        &quot;  Update map:       %d\n&quot;
        &quot;  Update data:      %d\n&quot;,
        update_map, update_data);
    if (update_data) {
      int i, a_delta;
      int quantizer[4] = {0, 0, 0, 0};
      int filter_strength[4] = {0, 0, 0, 0};
      GET_BITS(a_delta, 1);
      printf(&quot;  Absolute delta:   %d\n&quot;, a_delta);
      for (i = 0; i &lt; 4; ++i) {
        int bit;
        GET_BITS(bit, 1);
        if (bit) GET_SIGNED_BITS(quantizer[i], 7);
      }
      for (i = 0; i &lt; 4; ++i) {
        int bit;
        GET_BITS(bit, 1);
        if (bit) GET_SIGNED_BITS(filter_strength[i], 6);
      }
      printf(&quot;  Quantizer:        %d %d %d %d\n&quot;, quantizer[0], quantizer[1],
             quantizer[2], quantizer[3]);
      printf(&quot;  Filter strength:  %d %d %d %d\n&quot;, filter_strength[0],
             filter_strength[1], filter_strength[2], filter_strength[3]);
    }
    if (update_map) {
      int i;
      int prob_segment[3] = {255, 255, 255};
      for (i = 0; i &lt; 3; ++i) {
        int bit;
        GET_BITS(bit, 1);
        if (bit) GET_BITS(prob_segment[i], 8);
      }
      printf(&quot;  Prob segment:     %d %d %d\n&quot;, prob_segment[0], prob_segment[1],
             prob_segment[2]);
    }
  }
  return WEBP_INFO_OK;
}

static WebPInfoStatus ParseLossyFilterHeader(const WebPInfo* const webp_info,
                                             const uint8_t* const data,
                                             size_t data_size,
                                             uint64_t* const bit_pos) {
  int simple_filter, level, sharpness, use_lf_delta;
  GET_BITS(simple_filter, 1);
  GET_BITS(level, 6);
  GET_BITS(sharpness, 3);
  GET_BITS(use_lf_delta, 1);
  printf(&quot;  Simple filter:    %d\n&quot;, simple_filter);
  printf(&quot;  Level:            %d\n&quot;, level);
  printf(&quot;  Sharpness:        %d\n&quot;, sharpness);
  printf(&quot;  Use lf delta:     %d\n&quot;, use_lf_delta);
  if (use_lf_delta) {
    int update;
    GET_BITS(update, 1);
    printf(&quot;  Update lf delta:  %d\n&quot;, update);
    if (update) {
      int i;
      for (i = 0; i &lt; 4 + 4; ++i) {
        int temp;
        GET_BITS(temp, 1);
        if (temp) GET_BITS(temp, 7);
      }
    }
  }
  return WEBP_INFO_OK;
}

static WebPInfoStatus ParseLossyHeader(const ChunkData* const chunk_data,
                                       const WebPInfo* const webp_info) {
  const uint8_t* data = chunk_data-&gt;payload;
  size_t data_size = chunk_data-&gt;size - CHUNK_HEADER_SIZE;
  const uint32_t bits = (uint32_t)data[0] | (data[1] &lt;&lt; 8) | (data[2] &lt;&lt; 16);
  const int key_frame = !(bits &amp; 1);
  const int profile = (bits &gt;&gt; 1) &amp; 7;
  const int display = (bits &gt;&gt; 4) &amp; 1;
  const uint32_t partition0_length = (bits &gt;&gt; 5);
  WebPInfoStatus status = WEBP_INFO_OK;
  uint64_t bit_position = 0;
  uint64_t* const bit_pos = &amp;bit_position;
  int colorspace, clamp_type;
  printf(&quot;  Parsing lossy bitstream...\n&quot;);
  // Calling WebPGetFeatures() in ProcessImageChunk() should ensure this.
  assert(chunk_data-&gt;size &gt;= CHUNK_HEADER_SIZE + 10);
  if (profile &gt; 3) {
    LOG_ERROR(&quot;Unknown profile.&quot;);
    return WEBP_INFO_BITSTREAM_ERROR;
  }
  if (!display) {
    LOG_ERROR(&quot;Frame is not displayable.&quot;);
    return WEBP_INFO_BITSTREAM_ERROR;
  }
  data += 3;
  data_size -= 3;
  printf(
      &quot;  Key frame:        %s\n&quot;
      &quot;  Profile:          %d\n&quot;
      &quot;  Display:          Yes\n&quot;
      &quot;  Part. 0 length:   %d\n&quot;,
      key_frame ? &quot;Yes&quot; : &quot;No&quot;, profile, partition0_length);
  if (key_frame) {
    if (!(data[0] == 0x9d &amp;&amp; data[1] == 0x01 &amp;&amp; data[2] == 0x2a)) {
      LOG_ERROR(&quot;Invalid lossy bitstream signature.&quot;);
      return WEBP_INFO_BITSTREAM_ERROR;
    }
    printf(
        &quot;  Width:            %d\n&quot;
        &quot;  X scale:          %d\n&quot;
        &quot;  Height:           %d\n&quot;
        &quot;  Y scale:          %d\n&quot;,
        ((data[4] &lt;&lt; 8) | data[3]) &amp; 0x3fff, data[4] &gt;&gt; 6,
        ((data[6] &lt;&lt; 8) | data[5]) &amp; 0x3fff, data[6] &gt;&gt; 6);
    data += 7;
    data_size -= 7;
  } else {
    LOG_ERROR(&quot;Non-keyframe detected in lossy bitstream.&quot;);
    return WEBP_INFO_BITSTREAM_ERROR;
  }
  if (partition0_length &gt;= data_size) {
    LOG_ERROR(&quot;Bad partition length.&quot;);
    return WEBP_INFO_BITSTREAM_ERROR;
  }
  GET_BITS(colorspace, 1);
  GET_BITS(clamp_type, 1);
  printf(&quot;  Color space:      %d\n&quot;, colorspace);
  printf(&quot;  Clamp type:       %d\n&quot;, clamp_type);
  status = ParseLossySegmentHeader(webp_info, data, data_size, bit_pos);
  if (status != WEBP_INFO_OK) return status;
  status = ParseLossyFilterHeader(webp_info, data, data_size, bit_pos);
  if (status != WEBP_INFO_OK) return status;
  {  // Partition number and size.
    const uint8_t* part_size = data + partition0_length;
    int num_parts, i;
    size_t part_data_size;
    GET_BITS(num_parts, 2);
    num_parts = 1 &lt;&lt; num_parts;
    if ((int)(data_size - partition0_length) &lt; (num_parts - 1) * 3) {
      LOG_ERROR(&quot;Truncated lossy bitstream.&quot;);
      return WEBP_INFO_TRUNCATED_DATA;
    }
    part_data_size = data_size - partition0_length - (num_parts - 1) * 3;
    printf(&quot;  Total partitions: %d\n&quot;, num_parts);
    for (i = 1; i &lt; num_parts; ++i) {
      const size_t psize =
          part_size[0] | (part_size[1] &lt;&lt; 8) | (part_size[2] &lt;&lt; 16);
      if (psize &gt; part_data_size) {
        LOG_ERROR(&quot;Truncated partition.&quot;);
        return WEBP_INFO_TRUNCATED_DATA;
      }
      printf(&quot;  Part. %d length:   %d\n&quot;, i, (int)psize);
      part_data_size -= psize;
      part_size += 3;
    }
  }
  // Quantizer.
  {
    int base_q, bit;
    int dq_y1_dc = 0, dq_y2_dc = 0, dq_y2_ac = 0, dq_uv_dc = 0, dq_uv_ac = 0;
    GET_BITS(base_q, 7);
    GET_BITS(bit, 1);
    if (bit) GET_SIGNED_BITS(dq_y1_dc, 4);
    GET_BITS(bit, 1);
    if (bit) GET_SIGNED_BITS(dq_y2_dc, 4);
    GET_BITS(bit, 1);
    if (bit) GET_SIGNED_BITS(dq_y2_ac, 4);
    GET_BITS(bit, 1);
    if (bit) GET_SIGNED_BITS(dq_uv_dc, 4);
    GET_BITS(bit, 1);
    if (bit) GET_SIGNED_BITS(dq_uv_ac, 4);
    printf(&quot;  Base Q:           %d\n&quot;, base_q);
    printf(&quot;  DQ Y1 DC:         %d\n&quot;, dq_y1_dc);
    printf(&quot;  DQ Y2 DC:         %d\n&quot;, dq_y2_dc);
    printf(&quot;  DQ Y2 AC:         %d\n&quot;, dq_y2_ac);
    printf(&quot;  DQ UV DC:         %d\n&quot;, dq_uv_dc);
    printf(&quot;  DQ UV AC:         %d\n&quot;, dq_uv_ac);
  }
  if ((*bit_pos &gt;&gt; 3) &gt;= partition0_length) {
    LOG_ERROR(&quot;Truncated lossy bitstream.&quot;);
    return WEBP_INFO_TRUNCATED_DATA;
  }
  return WEBP_INFO_OK;
}

// -----------------------------------------------------------------------------
// Lossless bitstream analysis.

static int LLGetBits(const uint8_t* const data, size_t data_size, size_t nb,
                     int* val, uint64_t* const bit_pos) {
  uint32_t i = 0;
  *val = 0;
  while (i &lt; nb) {
    const uint64_t p = (*bit_pos)++;
    if ((p &gt;&gt; 3) &gt;= data_size) {
      return 0;
    } else {
      const int bit = !!(data[p &gt;&gt; 3] &amp; (1 &lt;&lt; ((p &amp; 7))));
      *val = *val | (bit &lt;&lt; i);
      ++i;
    }
  }
  return 1;
}

#define LL_GET_BITS(v, n)                                \
  do {                                                   \
    if (!LLGetBits(data, data_size, n, &amp;(v), bit_pos)) { \
      LOG_ERROR(&quot;Truncated lossless bitstream.&quot;);        \
      return WEBP_INFO_TRUNCATED_DATA;                   \
    }                                                    \
  } while (0)

static WebPInfoStatus ParseLosslessTransform(WebPInfo* const webp_info,
                                             const uint8_t* const data,
                                             size_t data_size,
                                             uint64_t* const bit_pos) {
  int use_transform, block_size, n_colors;
  LL_GET_BITS(use_transform, 1);
  printf(&quot;  Use transform:    %s\n&quot;, use_transform ? &quot;Yes&quot; : &quot;No&quot;);
  if (use_transform) {
    int type;
    LL_GET_BITS(type, 2);
    printf(&quot;  1st transform:    %s (%d)\n&quot;, kLosslessTransforms[type], type);
    switch (type) {
      case PREDICTOR_TRANSFORM:
      case CROSS_COLOR_TRANSFORM:
        LL_GET_BITS(block_size, 3);
        block_size = 1 &lt;&lt; (block_size + 2);
        printf(&quot;  Tran. block size: %d\n&quot;, block_size);
        break;
      case COLOR_INDEXING_TRANSFORM:
        LL_GET_BITS(n_colors, 8);
        n_colors += 1;
        printf(&quot;  No. of colors:    %d\n&quot;, n_colors);
        break;
      default:
        break;
    }
  }
  return WEBP_INFO_OK;
}

static WebPInfoStatus ParseLosslessHeader(const ChunkData* const chunk_data,
                                          WebPInfo* const webp_info) {
  const uint8_t* data = chunk_data-&gt;payload;
  size_t data_size = chunk_data-&gt;size - CHUNK_HEADER_SIZE;
  uint64_t bit_position = 0;
  uint64_t* const bit_pos = &amp;bit_position;
  WebPInfoStatus status;
  printf(&quot;  Parsing lossless bitstream...\n&quot;);
  if (data_size &lt; VP8L_FRAME_HEADER_SIZE) {
    LOG_ERROR(&quot;Truncated lossless bitstream.&quot;);
    return WEBP_INFO_TRUNCATED_DATA;
  }
  if (data[0] != VP8L_MAGIC_BYTE) {
    LOG_ERROR(&quot;Invalid lossless bitstream signature.&quot;);
    return WEBP_INFO_BITSTREAM_ERROR;
  }
  data += 1;
  data_size -= 1;
  {
    int width, height, has_alpha, version;
    LL_GET_BITS(width, 14);
    LL_GET_BITS(height, 14);
    LL_GET_BITS(has_alpha, 1);
    LL_GET_BITS(version, 3);
    width += 1;
    height += 1;
    printf(&quot;  Width:            %d\n&quot;, width);
    printf(&quot;  Height:           %d\n&quot;, height);
    printf(&quot;  Alpha:            %d\n&quot;, has_alpha);
    printf(&quot;  Version:          %d\n&quot;, version);
  }
  status = ParseLosslessTransform(webp_info, data, data_size, bit_pos);
  if (status != WEBP_INFO_OK) return status;
  return WEBP_INFO_OK;
}

static WebPInfoStatus ParseAlphaHeader(const ChunkData* const chunk_data,
                                       WebPInfo* const webp_info) {
  const uint8_t* data = chunk_data-&gt;payload;
  size_t data_size = chunk_data-&gt;size - CHUNK_HEADER_SIZE;
  if (data_size &lt;= ALPHA_HEADER_LEN) {
    LOG_ERROR(&quot;Truncated ALPH chunk.&quot;);
    return WEBP_INFO_TRUNCATED_DATA;
  }
  printf(&quot;  Parsing ALPH chunk...\n&quot;);
  {
    const int compression_method = (data[0] &gt;&gt; 0) &amp; 0x03;
    const int filter = (data[0] &gt;&gt; 2) &amp; 0x03;
    const int pre_processing = (data[0] &gt;&gt; 4) &amp; 0x03;
    const int reserved_bits = (data[0] &gt;&gt; 6) &amp; 0x03;
    printf(&quot;  Compression:      %d\n&quot;, compression_method);
    printf(&quot;  Filter:           %s (%d)\n&quot;, kAlphaFilterMethods[filter],
           filter);
    printf(&quot;  Pre-processing:   %d\n&quot;, pre_processing);
    if (compression_method &gt; ALPHA_LOSSLESS_COMPRESSION) {
      LOG_ERROR(&quot;Invalid Alpha compression method.&quot;);
      return WEBP_INFO_BITSTREAM_ERROR;
    }
    if (pre_processing &gt; ALPHA_PREPROCESSED_LEVELS) {
      LOG_ERROR(&quot;Invalid Alpha pre-processing method.&quot;);
      return WEBP_INFO_BITSTREAM_ERROR;
    }
    if (reserved_bits != 0) {
      LOG_WARN(&quot;Reserved bits in ALPH chunk header are not all 0.&quot;);
    }
    data += ALPHA_HEADER_LEN;
    data_size -= ALPHA_HEADER_LEN;
    if (compression_method == ALPHA_LOSSLESS_COMPRESSION) {
      uint64_t bit_pos = 0;
      WebPInfoStatus status =
          ParseLosslessTransform(webp_info, data, data_size, &amp;bit_pos);
      if (status != WEBP_INFO_OK) return status;
    }
  }
  return WEBP_INFO_OK;
}

// -----------------------------------------------------------------------------
// Chunk parsing.

static WebPInfoStatus ParseRIFFHeader(WebPInfo* const webp_info,
                                      MemBuffer* const mem) {
  const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;
  size_t riff_size;

  if (MemDataSize(mem) &lt; min_size) {
    LOG_ERROR(&quot;Truncated data detected when parsing RIFF header.&quot;);
    return WEBP_INFO_TRUNCATED_DATA;
  }
  if (memcmp(GetBuffer(mem), &quot;RIFF&quot;, CHUNK_SIZE_BYTES) ||
      memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, &quot;WEBP&quot;, CHUNK_SIZE_BYTES)) {
    LOG_ERROR(&quot;Corrupted RIFF header.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  riff_size = GetLE32(GetBuffer(mem) + TAG_SIZE);
  if (riff_size &lt; CHUNK_HEADER_SIZE) {
    LOG_ERROR(&quot;RIFF size is too small.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  if (riff_size &gt; MAX_CHUNK_PAYLOAD) {
    LOG_ERROR(&quot;RIFF size is over limit.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  riff_size += CHUNK_HEADER_SIZE;
  if (!webp_info-&gt;quiet) {
    printf(&quot;RIFF HEADER:\n&quot;);
    printf(&quot;  File size: %6d\n&quot;, (int)riff_size);
  }
  if (riff_size &lt; mem-&gt;end) {
    LOG_WARN(&quot;RIFF size is smaller than the file size.&quot;);
    mem-&gt;end = riff_size;
  } else if (riff_size &gt; mem-&gt;end) {
    LOG_ERROR(&quot;Truncated data detected when parsing RIFF payload.&quot;);
    return WEBP_INFO_TRUNCATED_DATA;
  }
  Skip(mem, RIFF_HEADER_SIZE);
  return WEBP_INFO_OK;
}

static WebPInfoStatus ParseChunk(const WebPInfo* const webp_info,
                                 MemBuffer* const mem,
                                 ChunkData* const chunk_data) {
  memset(chunk_data, 0, sizeof(*chunk_data));
  if (MemDataSize(mem) &lt; CHUNK_HEADER_SIZE) {
    LOG_ERROR(&quot;Truncated data detected when parsing chunk header.&quot;);
    return WEBP_INFO_TRUNCATED_DATA;
  } else {
    const size_t chunk_start_offset = mem-&gt;start;
    const uint32_t fourcc = ReadMemBufLE32(mem);
    const uint32_t payload_size = ReadMemBufLE32(mem);
    const uint32_t payload_size_padded = payload_size + (payload_size &amp; 1);
    const size_t chunk_size = CHUNK_HEADER_SIZE + payload_size_padded;
    int i;
    if (payload_size &gt; MAX_CHUNK_PAYLOAD) {
      LOG_ERROR(&quot;Size of chunk payload is over limit.&quot;);
      return WEBP_INFO_INVALID_PARAM;
    }
    if (payload_size_padded &gt; MemDataSize(mem)) {
      LOG_ERROR(&quot;Truncated data detected when parsing chunk payload.&quot;);
      return WEBP_INFO_TRUNCATED_DATA;
    }
    for (i = 0; i &lt; CHUNK_TYPES; ++i) {
      if (kWebPChunkTags[i] == fourcc) break;
    }
    chunk_data-&gt;offset = chunk_start_offset;
    chunk_data-&gt;size = chunk_size;
    chunk_data-&gt;id = (ChunkID)i;
    chunk_data-&gt;payload = GetBuffer(mem);
    if (chunk_data-&gt;id == CHUNK_ANMF) {
      if (payload_size != payload_size_padded) {
        LOG_ERROR(&quot;ANMF chunk size should always be even.&quot;);
        return WEBP_INFO_PARSE_ERROR;
      }
      // There are sub-chunks to be parsed in an ANMF chunk.
      Skip(mem, ANMF_CHUNK_SIZE);
    } else {
      Skip(mem, payload_size_padded);
    }
    return WEBP_INFO_OK;
  }
}

// -----------------------------------------------------------------------------
// Chunk analysis.

static WebPInfoStatus ProcessVP8XChunk(const ChunkData* const chunk_data,
                                       WebPInfo* const webp_info) {
  const uint8_t* data = chunk_data-&gt;payload;
  if (webp_info-&gt;chunk_counts[CHUNK_VP8] ||
      webp_info-&gt;chunk_counts[CHUNK_VP8L] ||
      webp_info-&gt;chunk_counts[CHUNK_VP8X]) {
    LOG_ERROR(&quot;Already seen a VP8/VP8L/VP8X chunk when parsing VP8X chunk.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  if (chunk_data-&gt;size != VP8X_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
    LOG_ERROR(&quot;Corrupted VP8X chunk.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  ++webp_info-&gt;chunk_counts[CHUNK_VP8X];
  webp_info-&gt;feature_flags = *data;
  data += 4;
  webp_info-&gt;canvas_width = 1 + ReadLE24(&amp;data);
  webp_info-&gt;canvas_height = 1 + ReadLE24(&amp;data);
  if (!webp_info-&gt;quiet) {
    printf(&quot;  ICCP: %d\n  Alpha: %d\n  EXIF: %d\n  XMP: %d\n  Animation: %d\n&quot;,
           (webp_info-&gt;feature_flags &amp; ICCP_FLAG) != 0,
           (webp_info-&gt;feature_flags &amp; ALPHA_FLAG) != 0,
           (webp_info-&gt;feature_flags &amp; EXIF_FLAG) != 0,
           (webp_info-&gt;feature_flags &amp; XMP_FLAG) != 0,
           (webp_info-&gt;feature_flags &amp; ANIMATION_FLAG) != 0);
    printf(&quot;  Canvas size %d x %d\n&quot;, webp_info-&gt;canvas_width,
           webp_info-&gt;canvas_height);
  }
  if (webp_info-&gt;canvas_width &gt; MAX_CANVAS_SIZE) {
    LOG_WARN(&quot;Canvas width is out of range in VP8X chunk.&quot;);
  }
  if (webp_info-&gt;canvas_height &gt; MAX_CANVAS_SIZE) {
    LOG_WARN(&quot;Canvas height is out of range in VP8X chunk.&quot;);
  }
  if ((uint64_t)webp_info-&gt;canvas_width * webp_info-&gt;canvas_height &gt;
      MAX_IMAGE_AREA) {
    LOG_WARN(&quot;Canvas area is out of range in VP8X chunk.&quot;);
  }
  return WEBP_INFO_OK;
}

static WebPInfoStatus ProcessANIMChunk(const ChunkData* const chunk_data,
                                       WebPInfo* const webp_info) {
  const uint8_t* data = chunk_data-&gt;payload;
  if (!webp_info-&gt;chunk_counts[CHUNK_VP8X]) {
    LOG_ERROR(&quot;ANIM chunk detected before VP8X chunk.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  if (chunk_data-&gt;size != ANIM_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
    LOG_ERROR(&quot;Corrupted ANIM chunk.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  webp_info-&gt;bgcolor = ReadLE32(&amp;data);
  webp_info-&gt;loop_count = ReadLE16(&amp;data);
  ++webp_info-&gt;chunk_counts[CHUNK_ANIM];
  if (!webp_info-&gt;quiet) {
    printf(&quot;  Background color:(ARGB) %02x %02x %02x %02x\n&quot;,
           (webp_info-&gt;bgcolor &gt;&gt; 24) &amp; 0xff, (webp_info-&gt;bgcolor &gt;&gt; 16) &amp; 0xff,
           (webp_info-&gt;bgcolor &gt;&gt; 8) &amp; 0xff, webp_info-&gt;bgcolor &amp; 0xff);
    printf(&quot;  Loop count      : %d\n&quot;, webp_info-&gt;loop_count);
  }
  if (webp_info-&gt;loop_count &gt; MAX_LOOP_COUNT) {
    LOG_WARN(&quot;Loop count is out of range in ANIM chunk.&quot;);
  }
  return WEBP_INFO_OK;
}

static WebPInfoStatus ProcessANMFChunk(const ChunkData* const chunk_data,
                                       WebPInfo* const webp_info) {
  const uint8_t* data = chunk_data-&gt;payload;
  int offset_x, offset_y, width, height, duration, blend, dispose, temp;
  if (webp_info-&gt;is_processing_anim_frame) {
    LOG_ERROR(&quot;ANMF chunk detected within another ANMF chunk.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  if (!webp_info-&gt;chunk_counts[CHUNK_ANIM]) {
    LOG_ERROR(&quot;ANMF chunk detected before ANIM chunk.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  if (chunk_data-&gt;size &lt;= CHUNK_HEADER_SIZE + ANMF_CHUNK_SIZE) {
    LOG_ERROR(&quot;Truncated data detected when parsing ANMF chunk.&quot;);
    return WEBP_INFO_TRUNCATED_DATA;
  }
  offset_x = 2 * ReadLE24(&amp;data);
  offset_y = 2 * ReadLE24(&amp;data);
  width = 1 + ReadLE24(&amp;data);
  height = 1 + ReadLE24(&amp;data);
  duration = ReadLE24(&amp;data);
  temp = *data;
  dispose = temp &amp; 1;
  blend = (temp &gt;&gt; 1) &amp; 1;
  ++webp_info-&gt;chunk_counts[CHUNK_ANMF];
  if (!webp_info-&gt;quiet) {
    printf(
        &quot;  Offset_X: %d\n  Offset_Y: %d\n  Width: %d\n  Height: %d\n&quot;
        &quot;  Duration: %d\n  Dispose: %d\n  Blend: %d\n&quot;,
        offset_x, offset_y, width, height, duration, dispose, blend);
  }
  if (duration &gt; MAX_DURATION) {
    LOG_ERROR(&quot;Invalid duration parameter in ANMF chunk.&quot;);
    return WEBP_INFO_INVALID_PARAM;
  }
  if (offset_x &gt; MAX_POSITION_OFFSET || offset_y &gt; MAX_POSITION_OFFSET) {
    LOG_ERROR(&quot;Invalid offset parameters in ANMF chunk.&quot;);
    return WEBP_INFO_INVALID_PARAM;
  }
  if ((uint64_t)offset_x + width &gt; (uint64_t)webp_info-&gt;canvas_width ||
      (uint64_t)offset_y + height &gt; (uint64_t)webp_info-&gt;canvas_height) {
    LOG_ERROR(&quot;Frame exceeds canvas in ANMF chunk.&quot;);
    return WEBP_INFO_INVALID_PARAM;
  }
  webp_info-&gt;is_processing_anim_frame = 1;
  webp_info-&gt;seen_alpha_subchunk = 0;
  webp_info-&gt;seen_image_subchunk = 0;
  webp_info-&gt;frame_width = width;
  webp_info-&gt;frame_height = height;
  webp_info-&gt;anim_frame_data_size =
      chunk_data-&gt;size - CHUNK_HEADER_SIZE - ANMF_CHUNK_SIZE;
  return WEBP_INFO_OK;
}

static WebPInfoStatus ProcessImageChunk(const ChunkData* const chunk_data,
                                        WebPInfo* const webp_info) {
  const uint8_t* data = chunk_data-&gt;payload - CHUNK_HEADER_SIZE;
  WebPBitstreamFeatures features;
  const VP8StatusCode vp8_status =
      WebPGetFeatures(data, chunk_data-&gt;size, &amp;features);
  if (vp8_status != VP8_STATUS_OK) {
    LOG_ERROR(&quot;VP8/VP8L bitstream error.&quot;);
    return WEBP_INFO_BITSTREAM_ERROR;
  }
  if (!webp_info-&gt;quiet) {
    assert(features.format &gt;= 0 &amp;&amp; features.format &lt;= 2);
    printf(
        &quot;  Width: %d\n  Height: %d\n  Alpha: %d\n  Animation: %d\n&quot;
        &quot;  Format: %s (%d)\n&quot;,
        features.width, features.height, features.has_alpha,
        features.has_animation, kFormats[features.format], features.format);
  }
  if (webp_info-&gt;is_processing_anim_frame) {
    ++webp_info-&gt;anmf_subchunk_counts[chunk_data-&gt;id == CHUNK_VP8 ? 0 : 1];
    if (chunk_data-&gt;id == CHUNK_VP8L &amp;&amp; webp_info-&gt;seen_alpha_subchunk) {
      LOG_ERROR(&quot;Both VP8L and ALPH sub-chunks are present in an ANMF chunk.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (webp_info-&gt;frame_width != features.width ||
        webp_info-&gt;frame_height != features.height) {
      LOG_ERROR(&quot;Frame size in VP8/VP8L sub-chunk differs from ANMF header.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (webp_info-&gt;seen_image_subchunk) {
      LOG_ERROR(&quot;Consecutive VP8/VP8L sub-chunks in an ANMF chunk.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    webp_info-&gt;seen_image_subchunk = 1;
  } else {
    if (webp_info-&gt;chunk_counts[CHUNK_VP8] ||
        webp_info-&gt;chunk_counts[CHUNK_VP8L]) {
      LOG_ERROR(&quot;Multiple VP8/VP8L chunks detected.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (chunk_data-&gt;id == CHUNK_VP8L &amp;&amp; webp_info-&gt;chunk_counts[CHUNK_ALPHA]) {
      LOG_WARN(&quot;Both VP8L and ALPH chunks are detected.&quot;);
    }
    if (webp_info-&gt;chunk_counts[CHUNK_ANIM] ||
        webp_info-&gt;chunk_counts[CHUNK_ANMF]) {
      LOG_ERROR(&quot;VP8/VP8L chunk and ANIM/ANMF chunk are both detected.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (webp_info-&gt;chunk_counts[CHUNK_VP8X]) {
      if (webp_info-&gt;canvas_width != features.width ||
          webp_info-&gt;canvas_height != features.height) {
        LOG_ERROR(&quot;Image size in VP8/VP8L chunk differs from VP8X chunk.&quot;);
        return WEBP_INFO_PARSE_ERROR;
      }
    } else {
      webp_info-&gt;canvas_width = features.width;
      webp_info-&gt;canvas_height = features.height;
      if (webp_info-&gt;canvas_width &lt; 1 || webp_info-&gt;canvas_height &lt; 1 ||
          webp_info-&gt;canvas_width &gt; MAX_CANVAS_SIZE ||
          webp_info-&gt;canvas_height &gt; MAX_CANVAS_SIZE ||
          (uint64_t)webp_info-&gt;canvas_width * webp_info-&gt;canvas_height &gt;
              MAX_IMAGE_AREA) {
        LOG_WARN(&quot;Invalid parameters in VP8/VP8L chunk.&quot;);
      }
    }
    ++webp_info-&gt;chunk_counts[chunk_data-&gt;id];
  }
  ++webp_info-&gt;num_frames;
  webp_info-&gt;has_alpha |= features.has_alpha;
  if (webp_info-&gt;parse_bitstream) {
    const int is_lossy = (chunk_data-&gt;id == CHUNK_VP8);
    const WebPInfoStatus status =
        is_lossy ? ParseLossyHeader(chunk_data, webp_info)
                 : ParseLosslessHeader(chunk_data, webp_info);
    if (status != WEBP_INFO_OK) return status;
  }
  return WEBP_INFO_OK;
}

static WebPInfoStatus ProcessALPHChunk(const ChunkData* const chunk_data,
                                       WebPInfo* const webp_info) {
  if (webp_info-&gt;is_processing_anim_frame) {
    ++webp_info-&gt;anmf_subchunk_counts[2];
    if (webp_info-&gt;seen_alpha_subchunk) {
      LOG_ERROR(&quot;Consecutive ALPH sub-chunks in an ANMF chunk.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    webp_info-&gt;seen_alpha_subchunk = 1;

    if (webp_info-&gt;seen_image_subchunk) {
      LOG_ERROR(
          &quot;ALPHA sub-chunk detected after VP8 sub-chunk &quot;
          &quot;in an ANMF chunk.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
  } else {
    if (webp_info-&gt;chunk_counts[CHUNK_ANIM] ||
        webp_info-&gt;chunk_counts[CHUNK_ANMF]) {
      LOG_ERROR(&quot;ALPHA chunk and ANIM/ANMF chunk are both detected.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (!webp_info-&gt;chunk_counts[CHUNK_VP8X]) {
      LOG_ERROR(&quot;ALPHA chunk detected before VP8X chunk.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (webp_info-&gt;chunk_counts[CHUNK_VP8]) {
      LOG_ERROR(&quot;ALPHA chunk detected after VP8 chunk.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (webp_info-&gt;chunk_counts[CHUNK_ALPHA]) {
      LOG_ERROR(&quot;Multiple ALPHA chunks detected.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    ++webp_info-&gt;chunk_counts[CHUNK_ALPHA];
  }
  webp_info-&gt;has_alpha = 1;
  if (webp_info-&gt;parse_bitstream) {
    const WebPInfoStatus status = ParseAlphaHeader(chunk_data, webp_info);
    if (status != WEBP_INFO_OK) return status;
  }
  return WEBP_INFO_OK;
}

static WebPInfoStatus ProcessICCPChunk(const ChunkData* const chunk_data,
                                       WebPInfo* const webp_info) {
  (void)chunk_data;
  if (!webp_info-&gt;chunk_counts[CHUNK_VP8X]) {
    LOG_ERROR(&quot;ICCP chunk detected before VP8X chunk.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  if (webp_info-&gt;chunk_counts[CHUNK_VP8] ||
      webp_info-&gt;chunk_counts[CHUNK_VP8L] ||
      webp_info-&gt;chunk_counts[CHUNK_ANIM]) {
    LOG_ERROR(&quot;ICCP chunk detected after image data.&quot;);
    return WEBP_INFO_PARSE_ERROR;
  }
  ++webp_info-&gt;chunk_counts[CHUNK_ICCP];
  return WEBP_INFO_OK;
}

static WebPInfoStatus ProcessChunk(const ChunkData* const chunk_data,
                                   WebPInfo* const webp_info) {
  WebPInfoStatus status = WEBP_INFO_OK;
  ChunkID id = chunk_data-&gt;id;
  if (chunk_data-&gt;id == CHUNK_UNKNOWN) {
    char error_message[50];
    snprintf(error_message, 50, &quot;Unknown chunk at offset %6d, length %6d&quot;,
             (int)chunk_data-&gt;offset, (int)chunk_data-&gt;size);
    LOG_WARN(error_message);
  } else {
    if (!webp_info-&gt;quiet) {
      char tag[4];
      uint32_t fourcc = kWebPChunkTags[chunk_data-&gt;id];
#ifdef WORDS_BIGENDIAN
      fourcc = (fourcc &gt;&gt; 24) | ((fourcc &gt;&gt; 8) &amp; 0xff00) |
               ((fourcc &lt;&lt; 8) &amp; 0xff0000) | (fourcc &lt;&lt; 24);
#endif
      memcpy(tag, &amp;fourcc, sizeof(tag));
      printf(&quot;Chunk %c%c%c%c at offset %6d, length %6d\n&quot;, tag[0], tag[1],
             tag[2], tag[3], (int)chunk_data-&gt;offset, (int)chunk_data-&gt;size);
    }
  }
  switch (id) {
    case CHUNK_VP8:
    case CHUNK_VP8L:
      status = ProcessImageChunk(chunk_data, webp_info);
      break;
    case CHUNK_VP8X:
      status = ProcessVP8XChunk(chunk_data, webp_info);
      break;
    case CHUNK_ALPHA:
      status = ProcessALPHChunk(chunk_data, webp_info);
      break;
    case CHUNK_ANIM:
      status = ProcessANIMChunk(chunk_data, webp_info);
      break;
    case CHUNK_ANMF:
      status = ProcessANMFChunk(chunk_data, webp_info);
      break;
    case CHUNK_ICCP:
      status = ProcessICCPChunk(chunk_data, webp_info);
      break;
    case CHUNK_EXIF:
    case CHUNK_XMP:
      ++webp_info-&gt;chunk_counts[id];
      break;
    case CHUNK_UNKNOWN:
    default:
      break;
  }
  if (webp_info-&gt;is_processing_anim_frame &amp;&amp; id != CHUNK_ANMF) {
    if (webp_info-&gt;anim_frame_data_size == chunk_data-&gt;size) {
      if (!webp_info-&gt;seen_image_subchunk) {
        LOG_ERROR(&quot;No VP8/VP8L chunk detected in an ANMF chunk.&quot;);
        return WEBP_INFO_PARSE_ERROR;
      }
      webp_info-&gt;is_processing_anim_frame = 0;
    } else if (webp_info-&gt;anim_frame_data_size &gt; chunk_data-&gt;size) {
      webp_info-&gt;anim_frame_data_size -= chunk_data-&gt;size;
    } else {
      LOG_ERROR(&quot;Truncated data detected when parsing ANMF chunk.&quot;);
      return WEBP_INFO_TRUNCATED_DATA;
    }
  }
  return status;
}

static WebPInfoStatus Validate(WebPInfo* const webp_info) {
  if (webp_info-&gt;num_frames &lt; 1) {
    LOG_ERROR(&quot;No image/frame detected.&quot;);
    return WEBP_INFO_MISSING_DATA;
  }
  if (webp_info-&gt;chunk_counts[CHUNK_VP8X]) {
    const int iccp = !!(webp_info-&gt;feature_flags &amp; ICCP_FLAG);
    const int exif = !!(webp_info-&gt;feature_flags &amp; EXIF_FLAG);
    const int xmp = !!(webp_info-&gt;feature_flags &amp; XMP_FLAG);
    const int animation = !!(webp_info-&gt;feature_flags &amp; ANIMATION_FLAG);
    const int alpha = !!(webp_info-&gt;feature_flags &amp; ALPHA_FLAG);
    if (!alpha &amp;&amp; webp_info-&gt;has_alpha) {
      LOG_ERROR(&quot;Unexpected alpha data detected.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (alpha &amp;&amp; !webp_info-&gt;has_alpha) {
      LOG_WARN(&quot;Alpha flag is set with no alpha data present.&quot;);
    }
    if (iccp &amp;&amp; !webp_info-&gt;chunk_counts[CHUNK_ICCP]) {
      LOG_ERROR(&quot;Missing ICCP chunk.&quot;);
      return WEBP_INFO_MISSING_DATA;
    }
    if (exif &amp;&amp; !webp_info-&gt;chunk_counts[CHUNK_EXIF]) {
      LOG_ERROR(&quot;Missing EXIF chunk.&quot;);
      return WEBP_INFO_MISSING_DATA;
    }
    if (xmp &amp;&amp; !webp_info-&gt;chunk_counts[CHUNK_XMP]) {
      LOG_ERROR(&quot;Missing XMP chunk.&quot;);
      return WEBP_INFO_MISSING_DATA;
    }
    if (!iccp &amp;&amp; webp_info-&gt;chunk_counts[CHUNK_ICCP]) {
      LOG_ERROR(&quot;Unexpected ICCP chunk detected.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (!exif &amp;&amp; webp_info-&gt;chunk_counts[CHUNK_EXIF]) {
      LOG_ERROR(&quot;Unexpected EXIF chunk detected.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (!xmp &amp;&amp; webp_info-&gt;chunk_counts[CHUNK_XMP]) {
      LOG_ERROR(&quot;Unexpected XMP chunk detected.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    // Incomplete animation frame.
    if (webp_info-&gt;is_processing_anim_frame) return WEBP_INFO_MISSING_DATA;
    if (!animation &amp;&amp; webp_info-&gt;num_frames &gt; 1) {
      LOG_ERROR(&quot;More than 1 frame detected in non-animation file.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
    if (animation &amp;&amp; (!webp_info-&gt;chunk_counts[CHUNK_ANIM] ||
                      !webp_info-&gt;chunk_counts[CHUNK_ANMF])) {
      LOG_ERROR(&quot;No ANIM/ANMF chunk detected in animation file.&quot;);
      return WEBP_INFO_PARSE_ERROR;
    }
  }
  return WEBP_INFO_OK;
}

static void ShowSummary(const WebPInfo* const webp_info) {
  int i;
  printf(&quot;Summary:\n&quot;);
  printf(&quot;Number of frames: %d\n&quot;, webp_info-&gt;num_frames);
  printf(
      &quot;Chunk type  :  VP8 VP8L VP8X ALPH ANIM ANMF(VP8 /VP8L/ALPH) ICCP &quot;
      &quot;EXIF  XMP\n&quot;);
  printf(&quot;Chunk counts: &quot;);
  for (i = 0; i &lt; CHUNK_TYPES; ++i) {
    printf(&quot;%4d &quot;, webp_info-&gt;chunk_counts[i]);
    if (i == CHUNK_ANMF) {
      printf(&quot;%4d %4d %4d  &quot;, webp_info-&gt;anmf_subchunk_counts[0],
             webp_info-&gt;anmf_subchunk_counts[1],
             webp_info-&gt;anmf_subchunk_counts[2]);
    }
  }
  printf(&quot;\n&quot;);
}

static WebPInfoStatus AnalyzeWebP(WebPInfo* const webp_info,
                                  const WebPData* webp_data) {
  ChunkData chunk_data;
  MemBuffer mem_buffer;
  WebPInfoStatus webp_info_status = WEBP_INFO_OK;

  InitMemBuffer(&amp;mem_buffer, webp_data);
  webp_info_status = ParseRIFFHeader(webp_info, &amp;mem_buffer);
  if (webp_info_status != WEBP_INFO_OK) goto Error;

  //  Loop through all the chunks. Terminate immediately in case of error.
  while (webp_info_status == WEBP_INFO_OK &amp;&amp; MemDataSize(&amp;mem_buffer) &gt; 0) {
    webp_info_status = ParseChunk(webp_info, &amp;mem_buffer, &amp;chunk_data);
    if (webp_info_status != WEBP_INFO_OK) goto Error;
    webp_info_status = ProcessChunk(&amp;chunk_data, webp_info);
  }
  if (webp_info_status != WEBP_INFO_OK) goto Error;
  if (webp_info-&gt;show_summary) ShowSummary(webp_info);

  //  Final check.
  webp_info_status = Validate(webp_info);

Error:
  if (!webp_info-&gt;quiet) {
    if (webp_info_status == WEBP_INFO_OK) {
      printf(&quot;No error detected.\n&quot;);
    } else {
      printf(&quot;Errors detected.\n&quot;);
    }
    if (webp_info-&gt;num_warnings &gt; 0) {
      printf(&quot;There were %d warning(s).\n&quot;, webp_info-&gt;num_warnings);
    }
  }
  return webp_info_status;
}

static void Help(void) {
  printf(
      &quot;Usage: webpinfo [options] in_files\n&quot;
      &quot;Note: there could be multiple input files;\n&quot;
      &quot;      options must come before input files.\n&quot;
      &quot;Options:\n&quot;
      &quot;  -version ........... Print version number and exit.\n&quot;
      &quot;  -quiet ............. Do not show chunk parsing information.\n&quot;
      &quot;  -diag .............. Show parsing error diagnosis.\n&quot;
      &quot;  -summary ........... Show chunk stats summary.\n&quot;
      &quot;  -bitstream_info .... Parse bitstream header.\n&quot;);
}

// Returns EXIT_SUCCESS on success, EXIT_FAILURE on failure.
int main(int argc, const char* argv[]) {
  int c, quiet = 0, show_diag = 0, show_summary = 0;
  int parse_bitstream = 0;
  WebPInfoStatus webp_info_status = WEBP_INFO_OK;
  WebPInfo webp_info;

  INIT_WARGV(argc, argv);

  if (argc == 1) {
    Help();
    FREE_WARGV_AND_RETURN(EXIT_FAILURE);
  }

  // Parse command-line input.
  for (c = 1; c &lt; argc; ++c) {
    if (!strcmp(argv[c], &quot;-h&quot;) || !strcmp(argv[c], &quot;-help&quot;) ||
        !strcmp(argv[c], &quot;-H&quot;) || !strcmp(argv[c], &quot;-longhelp&quot;)) {
      Help();
      FREE_WARGV_AND_RETURN(EXIT_SUCCESS);
    } else if (!strcmp(argv[c], &quot;-quiet&quot;)) {
      quiet = 1;
    } else if (!strcmp(argv[c], &quot;-diag&quot;)) {
      show_diag = 1;
    } else if (!strcmp(argv[c], &quot;-summary&quot;)) {
      show_summary = 1;
    } else if (!strcmp(argv[c], &quot;-bitstream_info&quot;)) {
      parse_bitstream = 1;
    } else if (!strcmp(argv[c], &quot;-version&quot;)) {
      const int version = WebPGetDecoderVersion();
      printf(&quot;WebP Decoder version: %d.%d.%d\n&quot;, (version &gt;&gt; 16) &amp; 0xff,
             (version &gt;&gt; 8) &amp; 0xff, version &amp; 0xff);
      FREE_WARGV_AND_RETURN(EXIT_SUCCESS);
    } else {  // Assume the remaining are all input files.
      break;
    }
  }

  if (c == argc) {
    Help();
    FREE_WARGV_AND_RETURN(EXIT_FAILURE);
  }

  // Process input files one by one.
  for (; c &lt; argc; ++c) {
    WebPData webp_data;
    const W_CHAR* in_file = NULL;
    WebPInfoInit(&amp;webp_info);
    webp_info.quiet = quiet;
    webp_info.show_diagnosis = show_diag;
    webp_info.show_summary = show_summary;
    webp_info.parse_bitstream = parse_bitstream;
    in_file = GET_WARGV(argv, c);
    if (in_file == NULL ||
        !ReadFileToWebPData((const char*)in_file, &amp;webp_data)) {
      webp_info_status = WEBP_INFO_INVALID_COMMAND;
      WFPRINTF(stderr, &quot;Failed to open input file %s.\n&quot;, in_file);
      continue;
    }
    if (!webp_info.quiet) WPRINTF(&quot;File: %s\n&quot;, in_file);
    webp_info_status = AnalyzeWebP(&amp;webp_info, &amp;webp_data);
    WebPDataClear(&amp;webp_data);
  }
  FREE_WARGV_AND_RETURN((webp_info_status == WEBP_INFO_OK) ? EXIT_SUCCESS
                                                           : EXIT_FAILURE);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fexamples'>🔙 Back</a></p>