�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: gif2webp.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.
// -----------------------------------------------------------------------------
//
//  simple tool to convert animated GIFs to WebP
//
// Authors: Skal (pascal.massimino@gmail.com)
//          Urvang (urvang@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

#ifdef WEBP_HAVE_GIF

#if defined(HAVE_UNISTD_H) &amp;&amp; HAVE_UNISTD_H
#include &lt;unistd.h&gt;
#endif

#include &lt;gif_lib.h&gt;

#include &quot;../imageio/imageio_util.h&quot;
#include &quot;./example_util.h&quot;
#include &quot;./gifdec.h&quot;
#include &quot;./unicode.h&quot;
#include &quot;./unicode_gif.h&quot;
#include &quot;sharpyuv/sharpyuv.h&quot;
#include &quot;webp/encode.h&quot;
#include &quot;webp/mux.h&quot;

#if !defined(STDIN_FILENO)
#define STDIN_FILENO 0
#endif

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

static int transparent_index = GIF_INDEX_INVALID;  // Opaque by default.

static const char* const kErrorMessages[-WEBP_MUX_NOT_ENOUGH_DATA + 1] = {
    &quot;WEBP_MUX_NOT_FOUND&quot;, &quot;WEBP_MUX_INVALID_ARGUMENT&quot;, &quot;WEBP_MUX_BAD_DATA&quot;,
    &quot;WEBP_MUX_MEMORY_ERROR&quot;, &quot;WEBP_MUX_NOT_ENOUGH_DATA&quot;};

static const char* ErrorString(WebPMuxError err) {
  assert(err &lt;= WEBP_MUX_NOT_FOUND &amp;&amp; err &gt;= WEBP_MUX_NOT_ENOUGH_DATA);
  return kErrorMessages[-err];
}

enum {
  METADATA_ICC = (1 &lt;&lt; 0),
  METADATA_XMP = (1 &lt;&lt; 1),
  METADATA_ALL = METADATA_ICC | METADATA_XMP
};

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

static void Help(void) {
  printf(&quot;Usage:\n&quot;);
  printf(&quot; gif2webp [options] gif_file -o webp_file\n&quot;);
  printf(&quot;Options:\n&quot;);
  printf(&quot;  -h / -help ............. this help\n&quot;);
  printf(&quot;  -lossy ................. encode image using lossy compression\n&quot;);
  printf(
      &quot;  -mixed ................. for each frame in the image, pick lossy\n&quot;
      &quot;                           or lossless compression heuristically\n&quot;);
  printf(
      &quot;  -near_lossless &lt;int&gt; ... use near-lossless image preprocessing\n&quot;
      &quot;                           (0..100=off), default=100\n&quot;);
  printf(
      &quot;  -sharp_yuv ............. use sharper (and slower) RGB-&gt;YUV &quot;
      &quot;conversion\n&quot;
      &quot;                           (lossy only)\n&quot;);
  printf(&quot;  -q &lt;float&gt; ............. quality factor (0:small..100:big)\n&quot;);
  printf(
      &quot;  -m &lt;int&gt; ............... compression method (0=fast, 6=slowest), &quot;
      &quot;default=4\n&quot;);
  printf(
      &quot;  -min_size .............. minimize output size (default:off)\n&quot;
      &quot;                           lossless compression by default; can be\n&quot;
      &quot;                           combined with -q, -m, -lossy or -mixed\n&quot;
      &quot;                           options\n&quot;);
  printf(&quot;  -kmin &lt;int&gt; ............ min distance between key frames\n&quot;);
  printf(&quot;  -kmax &lt;int&gt; ............ max distance between key frames\n&quot;);
  printf(&quot;  -f &lt;int&gt; ............... filter strength (0=off..100)\n&quot;);
  printf(&quot;  -metadata &lt;string&gt; ..... comma separated list of metadata to\n&quot;);
  printf(&quot;                           &quot;);
  printf(&quot;copy from the input to the output if present\n&quot;);
  printf(&quot;                           &quot;);
  printf(&quot;Valid values: all, none, icc, xmp (default)\n&quot;);
  printf(&quot;  -loop_compatibility .... use compatibility mode for Chrome\n&quot;);
  printf(&quot;                           version prior to M62 (inclusive)\n&quot;);
  printf(&quot;  -mt .................... use multi-threading if available\n&quot;);
  printf(&quot;\n&quot;);
  printf(&quot;  -version ............... print version number and exit\n&quot;);
  printf(&quot;  -v ..................... verbose\n&quot;);
  printf(&quot;  -quiet ................. don&#039;t print anything\n&quot;);
  printf(&quot;\n&quot;);
}

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

// Returns EXIT_SUCCESS on success, EXIT_FAILURE on failure.
int main(int argc, const char* argv[]) {
  int verbose = 0;
  int gif_error = GIF_ERROR;
  WebPMuxError err = WEBP_MUX_OK;
  int ok = 0;
  const W_CHAR *in_file = NULL, *out_file = NULL;
  GifFileType* gif = NULL;
  int frame_duration = 0;
  int frame_timestamp = 0;
  GIFDisposeMethod orig_dispose = GIF_DISPOSE_NONE;

  WebPPicture frame;        // Frame rectangle only (not disposed).
  WebPPicture curr_canvas;  // Not disposed.
  WebPPicture prev_canvas;  // Disposed.

  WebPAnimEncoder* enc = NULL;
  WebPAnimEncoderOptions enc_options;
  WebPConfig config;

  int frame_number = 0;  // Whether we are processing the first frame.
  int done;
  int c;
  int quiet = 0;
  WebPData webp_data;

  int keep_metadata = METADATA_XMP;  // ICC not output by default.
  WebPData icc_data;
  int stored_icc = 0;  // Whether we have already stored an ICC profile.
  WebPData xmp_data;
  int stored_xmp = 0;         // Whether we have already stored an XMP profile.
  int loop_count = 0;         // default: infinite
  int stored_loop_count = 0;  // Whether we have found an explicit loop count.
  int loop_compatibility = 0;
  WebPMux* mux = NULL;

  int default_kmin = 1;  // Whether to use default kmin value.
  int default_kmax = 1;

  INIT_WARGV(argc, argv);

  if (!WebPConfigInit(&amp;config) || !WebPAnimEncoderOptionsInit(&amp;enc_options) ||
      !WebPPictureInit(&amp;frame) || !WebPPictureInit(&amp;curr_canvas) ||
      !WebPPictureInit(&amp;prev_canvas)) {
    fprintf(stderr, &quot;Error! Version mismatch!\n&quot;);
    FREE_WARGV_AND_RETURN(EXIT_FAILURE);
  }
  config.lossless = 1;  // Use lossless compression by default.

  WebPDataInit(&amp;webp_data);
  WebPDataInit(&amp;icc_data);
  WebPDataInit(&amp;xmp_data);

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

  for (c = 1; c &lt; argc; ++c) {
    int parse_error = 0;
    if (!strcmp(argv[c], &quot;-h&quot;) || !strcmp(argv[c], &quot;-help&quot;)) {
      Help();
      FREE_WARGV_AND_RETURN(EXIT_SUCCESS);
    } else if (!strcmp(argv[c], &quot;-o&quot;) &amp;&amp; c &lt; argc - 1) {
      out_file = GET_WARGV(argv, ++c);
    } else if (!strcmp(argv[c], &quot;-lossy&quot;)) {
      config.lossless = 0;
    } else if (!strcmp(argv[c], &quot;-mixed&quot;)) {
      enc_options.allow_mixed = 1;
      config.lossless = 0;
    } else if (!strcmp(argv[c], &quot;-near_lossless&quot;) &amp;&amp; c &lt; argc - 1) {
      config.near_lossless = ExUtilGetInt(argv[++c], 0, &amp;parse_error);
    } else if (!strcmp(argv[c], &quot;-sharp_yuv&quot;)) {
      config.use_sharp_yuv = 1;
    } else if (!strcmp(argv[c], &quot;-loop_compatibility&quot;)) {
      loop_compatibility = 1;
    } else if (!strcmp(argv[c], &quot;-q&quot;) &amp;&amp; c &lt; argc - 1) {
      config.quality = ExUtilGetFloat(argv[++c], &amp;parse_error);
    } else if (!strcmp(argv[c], &quot;-m&quot;) &amp;&amp; c &lt; argc - 1) {
      config.method = ExUtilGetInt(argv[++c], 0, &amp;parse_error);
    } else if (!strcmp(argv[c], &quot;-min_size&quot;)) {
      enc_options.minimize_size = 1;
    } else if (!strcmp(argv[c], &quot;-kmax&quot;) &amp;&amp; c &lt; argc - 1) {
      enc_options.kmax = ExUtilGetInt(argv[++c], 0, &amp;parse_error);
      default_kmax = 0;
    } else if (!strcmp(argv[c], &quot;-kmin&quot;) &amp;&amp; c &lt; argc - 1) {
      enc_options.kmin = ExUtilGetInt(argv[++c], 0, &amp;parse_error);
      default_kmin = 0;
    } else if (!strcmp(argv[c], &quot;-f&quot;) &amp;&amp; c &lt; argc - 1) {
      config.filter_strength = ExUtilGetInt(argv[++c], 0, &amp;parse_error);
    } else if (!strcmp(argv[c], &quot;-metadata&quot;) &amp;&amp; c &lt; argc - 1) {
      static const struct {
        const char* option;
        int flag;
      } kTokens[] = {
          {&quot;all&quot;, METADATA_ALL},
          {&quot;none&quot;, 0},
          {&quot;icc&quot;, METADATA_ICC},
          {&quot;xmp&quot;, METADATA_XMP},
      };
      const size_t kNumTokens = sizeof(kTokens) / sizeof(*kTokens);
      const char* start = argv[++c];
      const char* const end = start + strlen(start);

      keep_metadata = 0;
      while (start &lt; end) {
        size_t i;
        const char* token = strchr(start, &#039;,&#039;);
        if (token == NULL) token = end;

        for (i = 0; i &lt; kNumTokens; ++i) {
          if ((size_t)(token - start) == strlen(kTokens[i].option) &amp;&amp;
              !strncmp(start, kTokens[i].option, strlen(kTokens[i].option))) {
            if (kTokens[i].flag != 0) {
              keep_metadata |= kTokens[i].flag;
            } else {
              keep_metadata = 0;
            }
            break;
          }
        }
        if (i == kNumTokens) {
          fprintf(stderr, &quot;Error! Unknown metadata type &#039;%.*s&#039;\n&quot;,
                  (int)(token - start), start);
          Help();
          FREE_WARGV_AND_RETURN(EXIT_FAILURE);
        }
        start = token + 1;
      }
    } else if (!strcmp(argv[c], &quot;-mt&quot;)) {
      ++config.thread_level;
    } else if (!strcmp(argv[c], &quot;-version&quot;)) {
      const int enc_version = WebPGetEncoderVersion();
      const int mux_version = WebPGetMuxVersion();
      const int sharpyuv_version = SharpYuvGetVersion();
      printf(&quot;WebP Encoder version: %d.%d.%d\nWebP Mux version: %d.%d.%d\n&quot;,
             (enc_version &gt;&gt; 16) &amp; 0xff, (enc_version &gt;&gt; 8) &amp; 0xff,
             enc_version &amp; 0xff, (mux_version &gt;&gt; 16) &amp; 0xff,
             (mux_version &gt;&gt; 8) &amp; 0xff, mux_version &amp; 0xff);
      printf(&quot;libsharpyuv: %d.%d.%d\n&quot;, (sharpyuv_version &gt;&gt; 24) &amp; 0xff,
             (sharpyuv_version &gt;&gt; 16) &amp; 0xffff, sharpyuv_version &amp; 0xff);
      FREE_WARGV_AND_RETURN(EXIT_SUCCESS);
    } else if (!strcmp(argv[c], &quot;-quiet&quot;)) {
      quiet = 1;
      enc_options.verbose = 0;
    } else if (!strcmp(argv[c], &quot;-v&quot;)) {
      verbose = 1;
      enc_options.verbose = 1;
    } else if (!strcmp(argv[c], &quot;--&quot;)) {
      if (c &lt; argc - 1) in_file = GET_WARGV(argv, ++c);
      break;
    } else if (argv[c][0] == &#039;-&#039;) {
      fprintf(stderr, &quot;Error! Unknown option &#039;%s&#039;\n&quot;, argv[c]);
      Help();
      FREE_WARGV_AND_RETURN(EXIT_FAILURE);
    } else {
      in_file = GET_WARGV(argv, c);
    }

    if (parse_error) {
      Help();
      FREE_WARGV_AND_RETURN(EXIT_FAILURE);
    }
  }

  // Appropriate default kmin, kmax values for lossy and lossless.
  if (default_kmin) {
    enc_options.kmin = config.lossless ? 9 : 3;
  }
  if (default_kmax) {
    enc_options.kmax = config.lossless ? 17 : 5;
  }

  if (!WebPValidateConfig(&amp;config)) {
    fprintf(stderr, &quot;Error! Invalid configuration.\n&quot;);
    goto End;
  }

  if (in_file == NULL) {
    fprintf(stderr, &quot;No input file specified!\n&quot;);
    Help();
    goto End;
  }

  // Start the decoder object
  gif = DGifOpenFileUnicode(in_file, &amp;gif_error);
  if (gif == NULL) goto End;

  // Loop over GIF images
  done = 0;
  do {
    GifRecordType type;
    if (DGifGetRecordType(gif, &amp;type) == GIF_ERROR) goto End;

    switch (type) {
      case IMAGE_DESC_RECORD_TYPE: {
        GIFFrameRect gif_rect;
        GifImageDesc* const image_desc = &amp;gif-&gt;Image;

        if (!DGifGetImageDesc(gif)) goto End;

        if (frame_number == 0) {
          if (verbose) {
            printf(&quot;Canvas screen: %d x %d\n&quot;, gif-&gt;SWidth, gif-&gt;SHeight);
          }
          // Fix some broken GIF global headers that report
          // 0 x 0 screen dimension.
          if (gif-&gt;SWidth == 0 || gif-&gt;SHeight == 0) {
            image_desc-&gt;Left = 0;
            image_desc-&gt;Top = 0;
            gif-&gt;SWidth = image_desc-&gt;Width;
            gif-&gt;SHeight = image_desc-&gt;Height;
            if (gif-&gt;SWidth &lt;= 0 || gif-&gt;SHeight &lt;= 0) {
              goto End;
            }
            if (verbose) {
              printf(&quot;Fixed canvas screen dimension to: %d x %d\n&quot;, gif-&gt;SWidth,
                     gif-&gt;SHeight);
            }
          }
          // Allocate current buffer.
          frame.width = gif-&gt;SWidth;
          frame.height = gif-&gt;SHeight;
          frame.use_argb = 1;
          if (!WebPPictureAlloc(&amp;frame)) goto End;
          GIFClearPic(&amp;frame, NULL);
          if (!(WebPPictureCopy(&amp;frame, &amp;curr_canvas) &amp;&amp;
                WebPPictureCopy(&amp;frame, &amp;prev_canvas))) {
            fprintf(stderr, &quot;Error allocating canvas.\n&quot;);
            goto End;
          }

          // Background color.
          GIFGetBackgroundColor(gif-&gt;SColorMap, gif-&gt;SBackGroundColor,
                                transparent_index,
                                &amp;enc_options.anim_params.bgcolor);

          // Initialize encoder.
          enc = WebPAnimEncoderNew(curr_canvas.width, curr_canvas.height,
                                   &amp;enc_options);
          if (enc == NULL) {
            fprintf(stderr,
                    &quot;Error! Could not create encoder object. Possibly due to &quot;
                    &quot;a memory error.\n&quot;);
            goto End;
          }
        }

        // Some even more broken GIF can have sub-rect with zero width/height.
        if (image_desc-&gt;Width == 0 || image_desc-&gt;Height == 0) {
          image_desc-&gt;Width = gif-&gt;SWidth;
          image_desc-&gt;Height = gif-&gt;SHeight;
        }

        if (!GIFReadFrame(gif, transparent_index, &amp;gif_rect, &amp;frame)) {
          goto End;
        }
        // Blend frame rectangle with previous canvas to compose full canvas.
        // Note that &#039;curr_canvas&#039; is same as &#039;prev_canvas&#039; at this point.
        GIFBlendFrames(&amp;frame, &amp;gif_rect, &amp;curr_canvas);

        if (!WebPAnimEncoderAdd(enc, &amp;curr_canvas, frame_timestamp, &amp;config)) {
          fprintf(stderr, &quot;Error while adding frame #%d: %s\n&quot;, frame_number,
                  WebPAnimEncoderGetError(enc));
          goto End;
        } else {
          ++frame_number;
        }

        // Update canvases.
        GIFDisposeFrame(orig_dispose, &amp;gif_rect, &amp;prev_canvas, &amp;curr_canvas);
        GIFCopyPixels(&amp;curr_canvas, &amp;prev_canvas);

        // Force frames with a small or no duration to 100ms to be consistent
        // with web browsers and other transcoding tools. This also avoids
        // incorrect durations between frames when padding frames are
        // discarded.
        if (frame_duration &lt;= 10) {
          frame_duration = 100;
        }

        // Update timestamp (for next frame).
        frame_timestamp += frame_duration;

        // In GIF, graphic control extensions are optional for a frame, so we
        // may not get one before reading the next frame. To handle this case,
        // we reset frame properties to reasonable defaults for the next frame.
        orig_dispose = GIF_DISPOSE_NONE;
        frame_duration = 0;
        transparent_index = GIF_INDEX_INVALID;
        break;
      }
      case EXTENSION_RECORD_TYPE: {
        int extension;
        GifByteType* data = NULL;
        if (DGifGetExtension(gif, &amp;extension, &amp;data) == GIF_ERROR) {
          goto End;
        }
        if (data == NULL) continue;

        switch (extension) {
          case COMMENT_EXT_FUNC_CODE: {
            break;  // Do nothing for now.
          }
          case GRAPHICS_EXT_FUNC_CODE: {
            if (!GIFReadGraphicsExtension(data, &amp;frame_duration, &amp;orig_dispose,
                                          &amp;transparent_index)) {
              goto End;
            }
            break;
          }
          case PLAINTEXT_EXT_FUNC_CODE: {
            break;
          }
          case APPLICATION_EXT_FUNC_CODE: {
            if (data[0] != 11) break;  // Chunk is too short
            if (!memcmp(data + 1, &quot;NETSCAPE2.0&quot;, 11) ||
                !memcmp(data + 1, &quot;ANIMEXTS1.0&quot;, 11)) {
              if (!GIFReadLoopCount(gif, &amp;data, &amp;loop_count)) {
                goto End;
              }
              if (verbose) {
                fprintf(stderr, &quot;Loop count: %d\n&quot;, loop_count);
              }
              stored_loop_count = loop_compatibility ? (loop_count != 0) : 1;
            } else {  // An extension containing metadata.
              // We only store the first encountered chunk of each type, and
              // only if requested by the user.
              const int is_xmp = (keep_metadata &amp; METADATA_XMP) &amp;&amp;
                                 !stored_xmp &amp;&amp;
                                 !memcmp(data + 1, &quot;XMP DataXMP&quot;, 11);
              const int is_icc = (keep_metadata &amp; METADATA_ICC) &amp;&amp;
                                 !stored_icc &amp;&amp;
                                 !memcmp(data + 1, &quot;ICCRGBG1012&quot;, 11);
              if (is_xmp || is_icc) {
                if (!GIFReadMetadata(gif, &amp;data,
                                     is_xmp ? &amp;xmp_data : &amp;icc_data)) {
                  goto End;
                }
                if (is_icc) {
                  stored_icc = 1;
                } else if (is_xmp) {
                  stored_xmp = 1;
                }
              }
            }
            break;
          }
          default: {
            break;  // skip
          }
        }
        while (data != NULL) {
          if (DGifGetExtensionNext(gif, &amp;data) == GIF_ERROR) goto End;
        }
        break;
      }
      case TERMINATE_RECORD_TYPE: {
        done = 1;
        break;
      }
      default: {
        if (verbose) {
          fprintf(stderr, &quot;Skipping over unknown record type %d\n&quot;, type);
        }
        break;
      }
    }
  } while (!done);

  // Last NULL frame.
  if (!WebPAnimEncoderAdd(enc, NULL, frame_timestamp, NULL)) {
    fprintf(stderr, &quot;Error flushing WebP muxer.\n&quot;);
    fprintf(stderr, &quot;%s\n&quot;, WebPAnimEncoderGetError(enc));
  }

  if (!WebPAnimEncoderAssemble(enc, &amp;webp_data)) {
    fprintf(stderr, &quot;%s\n&quot;, WebPAnimEncoderGetError(enc));
    goto End;
  }
  // If there&#039;s only one frame, we don&#039;t need to handle loop count.
  if (frame_number == 1) {
    loop_count = 0;
  } else if (!loop_compatibility) {
    if (!stored_loop_count) {
      // if no loop-count element is seen, the default is &#039;1&#039; (loop-once)
      // and we need to signal it explicitly in WebP. Note however that
      // in case there&#039;s a single frame, we still don&#039;t need to store it.
      if (frame_number &gt; 1) {
        stored_loop_count = 1;
        loop_count = 1;
      }
    } else if (loop_count &gt; 0 &amp;&amp; loop_count &lt; 65535) {
      // adapt GIF&#039;s semantic to WebP&#039;s (except in the infinite-loop case)
      loop_count += 1;
    }
  }
  // loop_count of 0 is the default (infinite), so no need to signal it
  if (loop_count == 0) stored_loop_count = 0;

  if (stored_loop_count || stored_icc || stored_xmp) {
    // Re-mux to add loop count and/or metadata as needed.
    mux = WebPMuxCreate(&amp;webp_data, 1);
    if (mux == NULL) {
      fprintf(stderr, &quot;ERROR: Could not re-mux to add loop count/metadata.\n&quot;);
      goto End;
    }
    WebPDataClear(&amp;webp_data);

    if (stored_loop_count) {  // Update loop count.
      WebPMuxAnimParams new_params;
      err = WebPMuxGetAnimationParams(mux, &amp;new_params);
      if (err != WEBP_MUX_OK) {
        fprintf(stderr, &quot;ERROR (%s): Could not fetch loop count.\n&quot;,
                ErrorString(err));
        goto End;
      }
      new_params.loop_count = loop_count;
      err = WebPMuxSetAnimationParams(mux, &amp;new_params);
      if (err != WEBP_MUX_OK) {
        fprintf(stderr, &quot;ERROR (%s): Could not update loop count.\n&quot;,
                ErrorString(err));
        goto End;
      }
    }

    if (stored_icc) {  // Add ICCP chunk.
      err = WebPMuxSetChunk(mux, &quot;ICCP&quot;, &amp;icc_data, 1);
      if (verbose) {
        fprintf(stderr, &quot;ICC size: %d\n&quot;, (int)icc_data.size);
      }
      if (err != WEBP_MUX_OK) {
        fprintf(stderr, &quot;ERROR (%s): Could not set ICC chunk.\n&quot;,
                ErrorString(err));
        goto End;
      }
    }

    if (stored_xmp) {  // Add XMP chunk.
      err = WebPMuxSetChunk(mux, &quot;XMP &quot;, &amp;xmp_data, 1);
      if (verbose) {
        fprintf(stderr, &quot;XMP size: %d\n&quot;, (int)xmp_data.size);
      }
      if (err != WEBP_MUX_OK) {
        fprintf(stderr, &quot;ERROR (%s): Could not set XMP chunk.\n&quot;,
                ErrorString(err));
        goto End;
      }
    }

    err = WebPMuxAssemble(mux, &amp;webp_data);
    if (err != WEBP_MUX_OK) {
      fprintf(stderr,
              &quot;ERROR (%s): Could not assemble when re-muxing to add &quot;
              &quot;loop count/metadata.\n&quot;,
              ErrorString(err));
      goto End;
    }
  }

  if (out_file != NULL) {
    if (!ImgIoUtilWriteFile((const char*)out_file, webp_data.bytes,
                            webp_data.size)) {
      WFPRINTF(stderr, &quot;Error writing output file: %s\n&quot;, out_file);
      goto End;
    }
    if (!quiet) {
      if (!WSTRCMP(out_file, &quot;-&quot;)) {
        fprintf(stderr, &quot;Saved %d bytes to STDIO\n&quot;, (int)webp_data.size);
      } else {
        WFPRINTF(stderr, &quot;Saved output file (%d bytes): %s\n&quot;,
                 (int)webp_data.size, out_file);
      }
    }
  } else {
    if (!quiet) {
      fprintf(stderr,
              &quot;Nothing written; use -o flag to save the result &quot;
              &quot;(%d bytes).\n&quot;,
              (int)webp_data.size);
    }
  }

  // All OK.
  ok = 1;
  gif_error = GIF_OK;

End:
  WebPDataClear(&amp;icc_data);
  WebPDataClear(&amp;xmp_data);
  WebPMuxDelete(mux);
  WebPDataClear(&amp;webp_data);
  WebPPictureFree(&amp;frame);
  WebPPictureFree(&amp;curr_canvas);
  WebPPictureFree(&amp;prev_canvas);
  WebPAnimEncoderDelete(enc);

  if (gif_error != GIF_OK) {
    GIFDisplayError(gif, gif_error);
  }
  if (gif != NULL) {
#if LOCAL_GIF_PREREQ(5, 1)
    DGifCloseFile(gif, &amp;gif_error);
#else
    DGifCloseFile(gif);
#endif
  }

  FREE_WARGV_AND_RETURN(ok ? EXIT_SUCCESS : EXIT_FAILURE);
}

#else  // !WEBP_HAVE_GIF

int main(int argc, const char* argv[]) {
  fprintf(stderr, &quot;GIF support not enabled in %s.\n&quot;, argv[0]);
  (void)argc;
  return EXIT_FAILURE;
}

#endif

//------------------------------------------------------------------------------
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fexamples'>🔙 Back</a></p>