�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: webpmux.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>// Copyright 2011 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 command-line to create a WebP container file and to extract or strip
//  relevant data from the container file.
//
// Authors: Vikas (vikaas.arora@gmail.com),
//          Urvang (urvang@google.com)

/*  Usage examples:

  Create container WebP file:
    webpmux -frame anim_1.webp +100+10+10   \
            -frame anim_2.webp +100+25+25+1 \
            -frame anim_3.webp +100+50+50+1 \
            -frame anim_4.webp +100         \
            -loop 10 -bgcolor 128,255,255,255 \
            -o out_animation_container.webp

    webpmux -set icc image_profile.icc in.webp -o out_icc_container.webp
    webpmux -set exif image_metadata.exif in.webp -o out_exif_container.webp
    webpmux -set xmp image_metadata.xmp in.webp -o out_xmp_container.webp
    webpmux -set loop 1 in.webp -o out_looped.webp

  Extract relevant data from WebP container file:
    webpmux -get frame n in.webp -o out_frame.webp
    webpmux -get icc in.webp -o image_profile.icc
    webpmux -get exif in.webp -o image_metadata.exif
    webpmux -get xmp in.webp -o image_metadata.xmp

  Strip data from WebP Container file:
    webpmux -strip icc in.webp -o out.webp
    webpmux -strip exif in.webp -o out.webp
    webpmux -strip xmp in.webp -o out.webp

  Change duration of frame intervals:
    webpmux -duration 150 in.webp -o out.webp
    webpmux -duration 33,2 in.webp -o out.webp
    webpmux -duration 200,10,0 -duration 150,6,50 in.webp -o out.webp

  Misc:
    webpmux -info in.webp
    webpmux [ -h | -help ]
    webpmux -version
    webpmux argument_file_name
*/

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

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

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

//------------------------------------------------------------------------------
// Config object to parse command-line arguments.

typedef enum {
  NIL_ACTION = 0,
  ACTION_GET,
  ACTION_SET,
  ACTION_STRIP,
  ACTION_INFO,
  ACTION_HELP,
  ACTION_DURATION
} ActionType;

typedef enum {
  NIL_SUBTYPE = 0,
  SUBTYPE_ANMF,
  SUBTYPE_LOOP,
  SUBTYPE_BGCOLOR
} FeatureSubType;

typedef struct {
  FeatureSubType subtype;
  const char* filename;
  const char* params;
} FeatureArg;

typedef enum {
  NIL_FEATURE = 0,
  FEATURE_EXIF,
  FEATURE_XMP,
  FEATURE_ICCP,
  FEATURE_ANMF,
  FEATURE_DURATION,
  FEATURE_LOOP,
  FEATURE_BGCOLOR,
  LAST_FEATURE
} FeatureType;

static const char* const kFourccList[LAST_FEATURE] = {NULL, &quot;EXIF&quot;, &quot;XMP &quot;,
                                                      &quot;ICCP&quot;, &quot;ANMF&quot;};

static const char* const kDescriptions[LAST_FEATURE] = {
    NULL, &quot;EXIF metadata&quot;, &quot;XMP metadata&quot;, &quot;ICC profile&quot;, &quot;Animation frame&quot;};

typedef struct {
  CommandLineArguments cmd_args;

  ActionType action_type;
  const char* input;
  const char* output;
  FeatureType type;
  FeatureArg* args;
  int arg_count;
} Config;

//------------------------------------------------------------------------------
// Helper functions.

static int CountOccurrences(const CommandLineArguments* const args,
                            const char* const arg) {
  int i;
  int num_occurences = 0;

  for (i = 0; i &lt; args-&gt;argc; ++i) {
    if (!strcmp(args-&gt;argv[i], arg)) {
      ++num_occurences;
    }
  }
  return num_occurences;
}

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];
}

#define RETURN_IF_ERROR(ERR_MSG) \
  do {                           \
    if (err != WEBP_MUX_OK) {    \
      fprintf(stderr, ERR_MSG);  \
      return err;                \
    }                            \
  } while (0)

#define RETURN_IF_ERROR3(ERR_MSG, FORMAT_STR1, FORMAT_STR2) \
  do {                                                      \
    if (err != WEBP_MUX_OK) {                               \
      fprintf(stderr, ERR_MSG, FORMAT_STR1, FORMAT_STR2);   \
      return err;                                           \
    }                                                       \
  } while (0)

#define ERROR_GOTO1(ERR_MSG, LABEL) \
  do {                              \
    fprintf(stderr, ERR_MSG);       \
    ok = 0;                         \
    goto LABEL;                     \
  } while (0)

#define ERROR_GOTO2(ERR_MSG, FORMAT_STR, LABEL) \
  do {                                          \
    fprintf(stderr, ERR_MSG, FORMAT_STR);       \
    ok = 0;                                     \
    goto LABEL;                                 \
  } while (0)

#define ERROR_GOTO3(ERR_MSG, FORMAT_STR1, FORMAT_STR2, LABEL) \
  do {                                                        \
    fprintf(stderr, ERR_MSG, FORMAT_STR1, FORMAT_STR2);       \
    ok = 0;                                                   \
    goto LABEL;                                               \
  } while (0)

static WebPMuxError DisplayInfo(const WebPMux* mux) {
  int width, height;
  uint32_t flag;

  WebPMuxError err = WebPMuxGetCanvasSize(mux, &amp;width, &amp;height);
  assert(err == WEBP_MUX_OK);  // As WebPMuxCreate() was successful earlier.
  printf(&quot;Canvas size: %d x %d\n&quot;, width, height);

  err = WebPMuxGetFeatures(mux, &amp;flag);
  RETURN_IF_ERROR(&quot;Failed to retrieve features\n&quot;);

  if (flag == 0) {
    printf(&quot;No features present.\n&quot;);
    return err;
  }

  // Print the features present.
  printf(&quot;Features present:&quot;);
  if (flag &amp; ANIMATION_FLAG) printf(&quot; animation&quot;);
  if (flag &amp; ICCP_FLAG) printf(&quot; ICC profile&quot;);
  if (flag &amp; EXIF_FLAG) printf(&quot; EXIF metadata&quot;);
  if (flag &amp; XMP_FLAG) printf(&quot; XMP metadata&quot;);
  if (flag &amp; ALPHA_FLAG) printf(&quot; transparency&quot;);
  printf(&quot;\n&quot;);

  if (flag &amp; ANIMATION_FLAG) {
    const WebPChunkId id = WEBP_CHUNK_ANMF;
    const char* const type_str = &quot;frame&quot;;
    int nFrames;

    WebPMuxAnimParams params;
    err = WebPMuxGetAnimationParams(mux, &amp;params);
    assert(err == WEBP_MUX_OK);
    printf(&quot;Background color : 0x%.8X  Loop Count : %d\n&quot;, params.bgcolor,
           params.loop_count);

    err = WebPMuxNumChunks(mux, id, &amp;nFrames);
    assert(err == WEBP_MUX_OK);

    printf(&quot;Number of %ss: %d\n&quot;, type_str, nFrames);
    if (nFrames &gt; 0) {
      int i;
      printf(&quot;No.: width height alpha x_offset y_offset &quot;);
      printf(&quot;duration   dispose blend &quot;);
      printf(&quot;image_size  compression\n&quot;);
      for (i = 1; i &lt;= nFrames; i++) {
        WebPMuxFrameInfo frame;
        err = WebPMuxGetFrame(mux, i, &amp;frame);
        if (err == WEBP_MUX_OK) {
          WebPBitstreamFeatures features;
          const VP8StatusCode status = WebPGetFeatures(
              frame.bitstream.bytes, frame.bitstream.size, &amp;features);
          assert(status == VP8_STATUS_OK);  // Checked by WebPMuxCreate().
          (void)status;
          printf(&quot;%3d: %5d %5d %5s %8d %8d &quot;, i, features.width,
                 features.height, features.has_alpha ? &quot;yes&quot; : &quot;no&quot;,
                 frame.x_offset, frame.y_offset);
          {
            const char* const dispose =
                (frame.dispose_method == WEBP_MUX_DISPOSE_NONE) ? &quot;none&quot;
                                                                : &quot;background&quot;;
            const char* const blend =
                (frame.blend_method == WEBP_MUX_BLEND) ? &quot;yes&quot; : &quot;no&quot;;
            printf(&quot;%8d %10s %5s &quot;, frame.duration, dispose, blend);
          }
          printf(&quot;%10d %11s\n&quot;, (int)frame.bitstream.size,
                 (features.format == 1)   ? &quot;lossy&quot;
                 : (features.format == 2) ? &quot;lossless&quot;
                                          : &quot;undefined&quot;);
        }
        WebPDataClear(&amp;frame.bitstream);
        RETURN_IF_ERROR3(&quot;Failed to retrieve %s#%d\n&quot;, type_str, i);
      }
    }
  }

  if (flag &amp; ICCP_FLAG) {
    WebPData icc_profile;
    err = WebPMuxGetChunk(mux, &quot;ICCP&quot;, &amp;icc_profile);
    assert(err == WEBP_MUX_OK);
    printf(&quot;Size of the ICC profile data: %d\n&quot;, (int)icc_profile.size);
  }

  if (flag &amp; EXIF_FLAG) {
    WebPData exif;
    err = WebPMuxGetChunk(mux, &quot;EXIF&quot;, &amp;exif);
    assert(err == WEBP_MUX_OK);
    printf(&quot;Size of the EXIF metadata: %d\n&quot;, (int)exif.size);
  }

  if (flag &amp; XMP_FLAG) {
    WebPData xmp;
    err = WebPMuxGetChunk(mux, &quot;XMP &quot;, &amp;xmp);
    assert(err == WEBP_MUX_OK);
    printf(&quot;Size of the XMP metadata: %d\n&quot;, (int)xmp.size);
  }

  if ((flag &amp; ALPHA_FLAG) &amp;&amp; !(flag &amp; ANIMATION_FLAG)) {
    WebPMuxFrameInfo image;
    err = WebPMuxGetFrame(mux, 1, &amp;image);
    if (err == WEBP_MUX_OK) {
      printf(&quot;Size of the image (with alpha): %d\n&quot;, (int)image.bitstream.size);
    }
    WebPDataClear(&amp;image.bitstream);
    RETURN_IF_ERROR(&quot;Failed to retrieve the image\n&quot;);
  }

  return WEBP_MUX_OK;
}

static void PrintHelp(void) {
  printf(&quot;Usage: webpmux -get GET_OPTIONS INPUT -o OUTPUT\n&quot;);
  printf(&quot;       webpmux -set SET_OPTIONS INPUT -o OUTPUT\n&quot;);
  printf(&quot;       webpmux -duration DURATION_OPTIONS [-duration ...]\n&quot;);
  printf(&quot;               INPUT -o OUTPUT\n&quot;);
  printf(&quot;       webpmux -strip STRIP_OPTIONS INPUT -o OUTPUT\n&quot;);
  printf(
      &quot;       webpmux -frame FRAME_OPTIONS [-frame...] [-loop LOOP_COUNT]&quot;
      &quot;\n&quot;);
  printf(&quot;               [-bgcolor BACKGROUND_COLOR] -o OUTPUT\n&quot;);
  printf(&quot;       webpmux -info INPUT\n&quot;);
  printf(&quot;       webpmux [-h|-help]\n&quot;);
  printf(&quot;       webpmux -version\n&quot;);
  printf(&quot;       webpmux argument_file_name\n&quot;);

  printf(&quot;\n&quot;);
  printf(&quot;GET_OPTIONS:\n&quot;);
  printf(&quot; Extract relevant data:\n&quot;);
  printf(&quot;   icc       get ICC profile\n&quot;);
  printf(&quot;   exif      get EXIF metadata\n&quot;);
  printf(&quot;   xmp       get XMP metadata\n&quot;);
  printf(&quot;   frame n   get nth frame\n&quot;);

  printf(&quot;\n&quot;);
  printf(&quot;SET_OPTIONS:\n&quot;);
  printf(&quot; Set color profile/metadata/parameters:\n&quot;);
  printf(&quot;   loop LOOP_COUNT            set the loop count\n&quot;);
  printf(&quot;   bgcolor BACKGROUND_COLOR   set the animation background color\n&quot;);
  printf(&quot;   icc  file.icc              set ICC profile\n&quot;);
  printf(&quot;   exif file.exif             set EXIF metadata\n&quot;);
  printf(&quot;   xmp  file.xmp              set XMP metadata\n&quot;);
  printf(&quot;   where:    &#039;file.icc&#039; contains the ICC profile to be set,\n&quot;);
  printf(&quot;             &#039;file.exif&#039; contains the EXIF metadata to be set\n&quot;);
  printf(&quot;             &#039;file.xmp&#039; contains the XMP metadata to be set\n&quot;);

  printf(&quot;\n&quot;);
  printf(&quot;DURATION_OPTIONS:\n&quot;);
  printf(&quot; Set duration of selected frames:\n&quot;);
  printf(&quot;   duration            set duration for all frames\n&quot;);
  printf(&quot;   duration,frame      set duration of a particular frame\n&quot;);
  printf(&quot;   duration,start,end  set duration of frames in the\n&quot;);
  printf(&quot;                        interval [start,end])\n&quot;);
  printf(&quot;   where: &#039;duration&#039; is the duration in milliseconds\n&quot;);
  printf(&quot;          &#039;start&#039; is the start frame index\n&quot;);
  printf(&quot;          &#039;end&#039; is the inclusive end frame index\n&quot;);
  printf(&quot;           The special &#039;end&#039; value &#039;0&#039; means: last frame.\n&quot;);

  printf(&quot;\n&quot;);
  printf(&quot;STRIP_OPTIONS:\n&quot;);
  printf(&quot; Strip color profile/metadata:\n&quot;);
  printf(&quot;   icc       strip ICC profile\n&quot;);
  printf(&quot;   exif      strip EXIF metadata\n&quot;);
  printf(&quot;   xmp       strip XMP metadata\n&quot;);

  printf(&quot;\n&quot;);
  printf(&quot;FRAME_OPTIONS(i):\n&quot;);
  printf(&quot; Create animation:\n&quot;);
  printf(&quot;   file_i +di[+xi+yi[+mi[bi]]]\n&quot;);
  printf(&quot;   where:    &#039;file_i&#039; is the i&#039;th animation frame (WebP format),\n&quot;);
  printf(&quot;             &#039;di&#039; is the pause duration before next frame,\n&quot;);
  printf(&quot;             &#039;xi&#039;,&#039;yi&#039; specify the image offset for this frame,\n&quot;);
  printf(&quot;             &#039;mi&#039; is the dispose method for this frame (0 or 1),\n&quot;);
  printf(
      &quot;             &#039;bi&#039; is the blending method for this frame (+b or -b)&quot;
      &quot;\n&quot;);

  printf(&quot;\n&quot;);
  printf(&quot;LOOP_COUNT:\n&quot;);
  printf(&quot; Number of times to repeat the animation.\n&quot;);
  printf(&quot; Valid range is 0 to 65535 [Default: 0 (infinite)].\n&quot;);

  printf(&quot;\n&quot;);
  printf(&quot;BACKGROUND_COLOR:\n&quot;);
  printf(&quot; Background color of the canvas.\n&quot;);
  printf(&quot;  A,R,G,B\n&quot;);
  printf(
      &quot;  where:    &#039;A&#039;, &#039;R&#039;, &#039;G&#039; and &#039;B&#039; are integers in the range 0 to 255 &quot;
      &quot;specifying\n&quot;);
  printf(
      &quot;            the Alpha, Red, Green and Blue component values &quot;
      &quot;respectively\n&quot;);
  printf(&quot;            [Default: 255,255,255,255]\n&quot;);

  printf(&quot;\nINPUT &amp; OUTPUT are in WebP format.\n&quot;);

  printf(&quot;\nNote: The nature of EXIF, XMP and ICC data is not checked&quot;);
  printf(&quot; and is assumed to be\nvalid.\n&quot;);
  printf(
      &quot;\nNote: if a single file name is passed as the argument, the &quot;
      &quot;arguments will be\n&quot;);
  printf(
      &quot;tokenized from this file. The file name must not start with &quot;
      &quot;the character &#039;-&#039;.\n&quot;);
}

static void WarnAboutOddOffset(const WebPMuxFrameInfo* const info) {
  if ((info-&gt;x_offset | info-&gt;y_offset) &amp; 1) {
    fprintf(stderr,
            &quot;Warning: odd offsets will be snapped to even values&quot;
            &quot; (%d, %d) -&gt; (%d, %d)\n&quot;,
            info-&gt;x_offset, info-&gt;y_offset, info-&gt;x_offset &amp; ~1,
            info-&gt;y_offset &amp; ~1);
  }
}

static int CreateMux(const char* const filename, WebPMux** mux) {
  WebPData bitstream;
  assert(mux != NULL);
  if (!ExUtilReadFileToWebPData(filename, &amp;bitstream)) return 0;
  *mux = WebPMuxCreate(&amp;bitstream, 1);
  WebPDataClear(&amp;bitstream);
  if (*mux != NULL) return 1;
  WFPRINTF(stderr, &quot;Failed to create mux object from file %s.\n&quot;,
           (const W_CHAR*)filename);
  return 0;
}

static int WriteData(const char* filename, const WebPData* const webpdata) {
  int ok = 0;
  FILE* fout = WSTRCMP(filename, &quot;-&quot;) ? WFOPEN(filename, &quot;wb&quot;)
                                      : ImgIoUtilSetBinaryMode(stdout);
  if (fout == NULL) {
    WFPRINTF(stderr, &quot;Error opening output WebP file %s!\n&quot;,
             (const W_CHAR*)filename);
    return 0;
  }
  if (fwrite(webpdata-&gt;bytes, webpdata-&gt;size, 1, fout) != 1) {
    WFPRINTF(stderr, &quot;Error writing file %s!\n&quot;, (const W_CHAR*)filename);
  } else {
    WFPRINTF(stderr, &quot;Saved file %s (%d bytes)\n&quot;, (const W_CHAR*)filename,
             (int)webpdata-&gt;size);
    ok = 1;
  }
  if (fout != stdout) fclose(fout);
  return ok;
}

static int WriteWebP(WebPMux* const mux, const char* filename) {
  int ok;
  WebPData webp_data;
  const WebPMuxError err = WebPMuxAssemble(mux, &amp;webp_data);
  if (err != WEBP_MUX_OK) {
    fprintf(stderr, &quot;Error (%s) assembling the WebP file.\n&quot;, ErrorString(err));
    return 0;
  }
  ok = WriteData(filename, &amp;webp_data);
  WebPDataClear(&amp;webp_data);
  return ok;
}

static WebPMux* DuplicateMuxHeader(const WebPMux* const mux) {
  WebPMux* new_mux = WebPMuxNew();
  WebPMuxAnimParams p;
  WebPMuxError err;
  int i;
  int ok = 1;

  if (new_mux == NULL) return NULL;

  err = WebPMuxGetAnimationParams(mux, &amp;p);
  if (err == WEBP_MUX_OK) {
    err = WebPMuxSetAnimationParams(new_mux, &amp;p);
    if (err != WEBP_MUX_OK) {
      ERROR_GOTO2(&quot;Error (%s) handling animation params.\n&quot;, ErrorString(err),
                  End);
    }
  } else {
    /* it might not be an animation. Just keep moving. */
  }

  for (i = 1; i &lt;= 3; ++i) {
    WebPData metadata;
    err = WebPMuxGetChunk(mux, kFourccList[i], &amp;metadata);
    if (err == WEBP_MUX_OK &amp;&amp; metadata.size &gt; 0) {
      err = WebPMuxSetChunk(new_mux, kFourccList[i], &amp;metadata, 1);
      if (err != WEBP_MUX_OK) {
        ERROR_GOTO1(&quot;Error transferring metadata in DuplicateMuxHeader().&quot;,
                    End);
      }
    }
  }

End:
  if (!ok) {
    WebPMuxDelete(new_mux);
    new_mux = NULL;
  }
  return new_mux;
}

static int ParseFrameArgs(const char* args, WebPMuxFrameInfo* const info) {
  int dispose_method, unused;
  char plus_minus, blend_method;
  const int num_args = sscanf(args, &quot;+%d+%d+%d+%d%c%c+%d&quot;, &amp;info-&gt;duration,
                              &amp;info-&gt;x_offset, &amp;info-&gt;y_offset, &amp;dispose_method,
                              &amp;plus_minus, &amp;blend_method, &amp;unused);
  switch (num_args) {
    case 1:
      info-&gt;x_offset = info-&gt;y_offset = 0;
      WEBP_FALLTHROUGH;
      // fall through
    case 3:
      dispose_method = 0;
      WEBP_FALLTHROUGH;
      // fall through
    case 4:
      plus_minus = &#039;+&#039;;
      blend_method = &#039;b&#039;;
      WEBP_FALLTHROUGH;
      // fall through
    case 6:
      break;
    case 2:
    case 5:
    default:
      return 0;
  }

  WarnAboutOddOffset(info);

  // Note: The validity of the following conversion is checked by
  // WebPMuxPushFrame().
  info-&gt;dispose_method = (WebPMuxAnimDispose)dispose_method;

  if (blend_method != &#039;b&#039;) return 0;
  if (plus_minus != &#039;-&#039; &amp;&amp; plus_minus != &#039;+&#039;) return 0;
  info-&gt;blend_method = (plus_minus == &#039;+&#039;) ? WEBP_MUX_BLEND : WEBP_MUX_NO_BLEND;
  return 1;
}

static int ParseBgcolorArgs(const char* args, uint32_t* const bgcolor) {
  uint32_t a, r, g, b;
  if (sscanf(args, &quot;%u,%u,%u,%u&quot;, &amp;a, &amp;r, &amp;g, &amp;b) != 4) return 0;
  if (a &gt;= 256 || r &gt;= 256 || g &gt;= 256 || b &gt;= 256) return 0;
  *bgcolor = (a &lt;&lt; 24) | (r &lt;&lt; 16) | (g &lt;&lt; 8) | (b &lt;&lt; 0);
  return 1;
}

//------------------------------------------------------------------------------
// Clean-up.

static void DeleteConfig(Config* const config) {
  if (config != NULL) {
    free(config-&gt;args);
    ExUtilDeleteCommandLineArguments(&amp;config-&gt;cmd_args);
    memset(config, 0, sizeof(*config));
  }
}

//------------------------------------------------------------------------------
// Parsing.

// Basic syntactic checks on the command-line arguments.
// Returns 1 on valid, 0 otherwise.
// Also fills up num_feature_args to be number of feature arguments given.
// (e.g. if there are 4 &#039;-frame&#039;s and 1 &#039;-loop&#039;, then num_feature_args = 5).
static int ValidateCommandLine(const CommandLineArguments* const cmd_args,
                               int* num_feature_args) {
  int num_frame_args;
  int num_loop_args;
  int num_bgcolor_args;
  int num_durations_args;
  int ok = 1;

  assert(num_feature_args != NULL);
  *num_feature_args = 0;

  // Simple checks.
  if (CountOccurrences(cmd_args, &quot;-get&quot;) &gt; 1) {
    ERROR_GOTO1(&quot;ERROR: Multiple &#039;-get&#039; arguments specified.\n&quot;, ErrValidate);
  }
  if (CountOccurrences(cmd_args, &quot;-set&quot;) &gt; 1) {
    ERROR_GOTO1(&quot;ERROR: Multiple &#039;-set&#039; arguments specified.\n&quot;, ErrValidate);
  }
  if (CountOccurrences(cmd_args, &quot;-strip&quot;) &gt; 1) {
    ERROR_GOTO1(&quot;ERROR: Multiple &#039;-strip&#039; arguments specified.\n&quot;, ErrValidate);
  }
  if (CountOccurrences(cmd_args, &quot;-info&quot;) &gt; 1) {
    ERROR_GOTO1(&quot;ERROR: Multiple &#039;-info&#039; arguments specified.\n&quot;, ErrValidate);
  }
  if (CountOccurrences(cmd_args, &quot;-o&quot;) &gt; 1) {
    ERROR_GOTO1(&quot;ERROR: Multiple output files specified.\n&quot;, ErrValidate);
  }

  // Compound checks.
  num_frame_args = CountOccurrences(cmd_args, &quot;-frame&quot;);
  num_loop_args = CountOccurrences(cmd_args, &quot;-loop&quot;);
  num_bgcolor_args = CountOccurrences(cmd_args, &quot;-bgcolor&quot;);
  num_durations_args = CountOccurrences(cmd_args, &quot;-duration&quot;);

  if (num_loop_args &gt; 1) {
    ERROR_GOTO1(&quot;ERROR: Multiple loop counts specified.\n&quot;, ErrValidate);
  }
  if (num_bgcolor_args &gt; 1) {
    ERROR_GOTO1(&quot;ERROR: Multiple background colors specified.\n&quot;, ErrValidate);
  }

  if ((num_frame_args == 0) &amp;&amp; (num_loop_args + num_bgcolor_args &gt; 0)) {
    ERROR_GOTO1(
        &quot;ERROR: Loop count and background color are relevant only in &quot;
        &quot;case of animation.\n&quot;,
        ErrValidate);
  }
  if (num_durations_args &gt; 0 &amp;&amp; num_frame_args != 0) {
    ERROR_GOTO1(&quot;ERROR: Can not combine -duration and -frame commands.\n&quot;,
                ErrValidate);
  }

  assert(ok == 1);
  if (num_durations_args &gt; 0) {
    *num_feature_args = num_durations_args;
  } else if (num_frame_args == 0) {
    // Single argument (&#039;set&#039; action for ICCP/EXIF/XMP, OR a &#039;get&#039; action).
    *num_feature_args = 1;
  } else {
    // Multiple arguments (&#039;set&#039; action for animation)
    *num_feature_args = num_frame_args + num_loop_args + num_bgcolor_args;
  }

ErrValidate:
  return ok;
}

#define ACTION_IS_NIL (config-&gt;action_type == NIL_ACTION)

#define FEATURETYPE_IS_NIL (config-&gt;type == NIL_FEATURE)

#define CHECK_NUM_ARGS_AT_LEAST(NUM, LABEL)                             \
  do {                                                                  \
    if (argc &lt; i + (NUM)) {                                             \
      fprintf(stderr, &quot;ERROR: Too few arguments for &#039;%s&#039;.\n&quot;, argv[i]); \
      goto LABEL;                                                       \
    }                                                                   \
  } while (0)

#define CHECK_NUM_ARGS_AT_MOST(NUM, LABEL)                               \
  do {                                                                   \
    if (argc &gt; i + (NUM)) {                                              \
      fprintf(stderr, &quot;ERROR: Too many arguments for &#039;%s&#039;.\n&quot;, argv[i]); \
      goto LABEL;                                                        \
    }                                                                    \
  } while (0)

#define CHECK_NUM_ARGS_EXACTLY(NUM, LABEL) \
  do {                                     \
    CHECK_NUM_ARGS_AT_LEAST(NUM, LABEL);   \
    CHECK_NUM_ARGS_AT_MOST(NUM, LABEL);    \
  } while (0)

// Parses command-line arguments to fill up config object. Also performs some
// semantic checks. unicode_argv contains wchar_t arguments or is null.
static int ParseCommandLine(Config* config, const W_CHAR** const unicode_argv) {
  int i = 0;
  int feature_arg_index = 0;
  int ok = 1;
  int argc = config-&gt;cmd_args.argc;
  const char* const* argv = config-&gt;cmd_args.argv;
  // Unicode file paths will be used if available.
  const char* const* wargv =
      (unicode_argv != NULL) ? (const char**)(unicode_argv + 1) : argv;

  while (i &lt; argc) {
    FeatureArg* const arg = &amp;config-&gt;args[feature_arg_index];
    if (argv[i][0] == &#039;-&#039;) {  // One of the action types or output.
      if (!strcmp(argv[i], &quot;-set&quot;)) {
        if (ACTION_IS_NIL) {
          config-&gt;action_type = ACTION_SET;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple actions specified.\n&quot;, ErrParse);
        }
        ++i;
      } else if (!strcmp(argv[i], &quot;-duration&quot;)) {
        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
        if (ACTION_IS_NIL || config-&gt;action_type == ACTION_DURATION) {
          config-&gt;action_type = ACTION_DURATION;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple actions specified.\n&quot;, ErrParse);
        }
        if (FEATURETYPE_IS_NIL || config-&gt;type == FEATURE_DURATION) {
          config-&gt;type = FEATURE_DURATION;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple features specified.\n&quot;, ErrParse);
        }
        arg-&gt;params = argv[i + 1];
        ++feature_arg_index;
        i += 2;
      } else if (!strcmp(argv[i], &quot;-get&quot;)) {
        if (ACTION_IS_NIL) {
          config-&gt;action_type = ACTION_GET;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple actions specified.\n&quot;, ErrParse);
        }
        ++i;
      } else if (!strcmp(argv[i], &quot;-strip&quot;)) {
        if (ACTION_IS_NIL) {
          config-&gt;action_type = ACTION_STRIP;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple actions specified.\n&quot;, ErrParse);
        }
        ++i;
      } else if (!strcmp(argv[i], &quot;-frame&quot;)) {
        CHECK_NUM_ARGS_AT_LEAST(3, ErrParse);
        if (ACTION_IS_NIL || config-&gt;action_type == ACTION_SET) {
          config-&gt;action_type = ACTION_SET;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple actions specified.\n&quot;, ErrParse);
        }
        if (FEATURETYPE_IS_NIL || config-&gt;type == FEATURE_ANMF) {
          config-&gt;type = FEATURE_ANMF;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple features specified.\n&quot;, ErrParse);
        }
        arg-&gt;subtype = SUBTYPE_ANMF;
        arg-&gt;filename = wargv[i + 1];
        arg-&gt;params = argv[i + 2];
        ++feature_arg_index;
        i += 3;
      } else if (!strcmp(argv[i], &quot;-loop&quot;) || !strcmp(argv[i], &quot;-bgcolor&quot;)) {
        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
        if (ACTION_IS_NIL || config-&gt;action_type == ACTION_SET) {
          config-&gt;action_type = ACTION_SET;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple actions specified.\n&quot;, ErrParse);
        }
        if (FEATURETYPE_IS_NIL || config-&gt;type == FEATURE_ANMF) {
          config-&gt;type = FEATURE_ANMF;
        } else {
          ERROR_GOTO1(&quot;ERROR: Multiple features specified.\n&quot;, ErrParse);
        }
        arg-&gt;subtype =
            !strcmp(argv[i], &quot;-loop&quot;) ? SUBTYPE_LOOP : SUBTYPE_BGCOLOR;
        arg-&gt;params = argv[i + 1];
        ++feature_arg_index;
        i += 2;
      } else if (!strcmp(argv[i], &quot;-o&quot;)) {
        CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
        config-&gt;output = wargv[i + 1];
        i += 2;
      } else if (!strcmp(argv[i], &quot;-info&quot;)) {
        CHECK_NUM_ARGS_EXACTLY(2, ErrParse);
        if (config-&gt;action_type != NIL_ACTION) {
          ERROR_GOTO1(&quot;ERROR: Multiple actions specified.\n&quot;, ErrParse);
        } else {
          config-&gt;action_type = ACTION_INFO;
          config-&gt;arg_count = 0;
          config-&gt;input = wargv[i + 1];
        }
        i += 2;
      } else if (!strcmp(argv[i], &quot;-h&quot;) || !strcmp(argv[i], &quot;-help&quot;)) {
        PrintHelp();
        DeleteConfig(config);
        LOCAL_FREE((W_CHAR**)unicode_argv);
        exit(0);
      } else if (!strcmp(argv[i], &quot;-version&quot;)) {
        const int version = WebPGetMuxVersion();
        printf(&quot;%d.%d.%d\n&quot;, (version &gt;&gt; 16) &amp; 0xff, (version &gt;&gt; 8) &amp; 0xff,
               version &amp; 0xff);
        DeleteConfig(config);
        LOCAL_FREE((W_CHAR**)unicode_argv);
        exit(0);
      } else if (!strcmp(argv[i], &quot;--&quot;)) {
        if (i &lt; argc - 1) {
          ++i;
          if (config-&gt;input == NULL) {
            config-&gt;input = wargv[i];
          } else {
            ERROR_GOTO2(&quot;ERROR at &#039;%s&#039;: Multiple input files specified.\n&quot;,
                        argv[i], ErrParse);
          }
        }
        break;
      } else {
        ERROR_GOTO2(&quot;ERROR: Unknown option: &#039;%s&#039;.\n&quot;, argv[i], ErrParse);
      }
    } else {  // One of the feature types or input.
      // After consuming the arguments to -get/-set/-strip, treat any remaining
      // arguments as input. This allows files that are named the same as the
      // keywords used with these options.
      int is_input = feature_arg_index == config-&gt;arg_count;
      if (ACTION_IS_NIL) {
        ERROR_GOTO1(&quot;ERROR: Action must be specified before other arguments.\n&quot;,
                    ErrParse);
      }
      if (!is_input) {
        if (!strcmp(argv[i], &quot;icc&quot;) || !strcmp(argv[i], &quot;exif&quot;) ||
            !strcmp(argv[i], &quot;xmp&quot;)) {
          if (FEATURETYPE_IS_NIL) {
            config-&gt;type = (!strcmp(argv[i], &quot;icc&quot;))    ? FEATURE_ICCP
                           : (!strcmp(argv[i], &quot;exif&quot;)) ? FEATURE_EXIF
                                                        : FEATURE_XMP;
          } else {
            ERROR_GOTO1(&quot;ERROR: Multiple features specified.\n&quot;, ErrParse);
          }
          if (config-&gt;action_type == ACTION_SET) {
            CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
            arg-&gt;filename = wargv[i + 1];
            ++feature_arg_index;
            i += 2;
          } else {
            // Note: &#039;arg-&gt;params&#039; is not used in this case. &#039;arg_count&#039; is
            // used as a flag to indicate the -get/-strip feature has already
            // been consumed, allowing input types to be named the same as the
            // feature type.
            config-&gt;arg_count = 0;
            ++i;
          }
        } else if (!strcmp(argv[i], &quot;frame&quot;) &amp;&amp;
                   (config-&gt;action_type == ACTION_GET)) {
          CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
          config-&gt;type = FEATURE_ANMF;
          arg-&gt;params = argv[i + 1];
          ++feature_arg_index;
          i += 2;
        } else if (!strcmp(argv[i], &quot;loop&quot;) &amp;&amp;
                   (config-&gt;action_type == ACTION_SET)) {
          CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
          config-&gt;type = FEATURE_LOOP;
          arg-&gt;params = argv[i + 1];
          ++feature_arg_index;
          i += 2;
        } else if (!strcmp(argv[i], &quot;bgcolor&quot;) &amp;&amp;
                   (config-&gt;action_type == ACTION_SET)) {
          CHECK_NUM_ARGS_AT_LEAST(2, ErrParse);
          config-&gt;type = FEATURE_BGCOLOR;
          arg-&gt;params = argv[i + 1];
          ++feature_arg_index;
          i += 2;
        } else {
          is_input = 1;
        }
      }

      if (is_input) {
        if (config-&gt;input == NULL) {
          config-&gt;input = wargv[i];
        } else {
          ERROR_GOTO2(&quot;ERROR at &#039;%s&#039;: Multiple input files specified.\n&quot;,
                      argv[i], ErrParse);
        }
        ++i;
      }
    }
  }
ErrParse:
  return ok;
}

// Additional checks after config is filled.
static int ValidateConfig(Config* const config) {
  int ok = 1;

  // Action.
  if (ACTION_IS_NIL) {
    ERROR_GOTO1(&quot;ERROR: No action specified.\n&quot;, ErrValidate2);
  }

  // Feature type.
  if (FEATURETYPE_IS_NIL &amp;&amp; config-&gt;action_type != ACTION_INFO) {
    ERROR_GOTO1(&quot;ERROR: No feature specified.\n&quot;, ErrValidate2);
  }

  // Input file.
  if (config-&gt;input == NULL) {
    if (config-&gt;action_type != ACTION_SET) {
      ERROR_GOTO1(&quot;ERROR: No input file specified.\n&quot;, ErrValidate2);
    } else if (config-&gt;type != FEATURE_ANMF) {
      ERROR_GOTO1(&quot;ERROR: No input file specified.\n&quot;, ErrValidate2);
    }
  }

  // Output file.
  if (config-&gt;output == NULL &amp;&amp; config-&gt;action_type != ACTION_INFO) {
    ERROR_GOTO1(&quot;ERROR: No output file specified.\n&quot;, ErrValidate2);
  }

ErrValidate2:
  return ok;
}

// Create config object from command-line arguments.
static int InitializeConfig(int argc, const char* argv[], Config* const config,
                            const W_CHAR** const unicode_argv) {
  int num_feature_args = 0;
  int ok;

  memset(config, 0, sizeof(*config));

  ok = ExUtilInitCommandLineArguments(argc, argv, &amp;config-&gt;cmd_args);
  if (!ok) return 0;

  // Validate command-line arguments.
  if (!ValidateCommandLine(&amp;config-&gt;cmd_args, &amp;num_feature_args)) {
    ERROR_GOTO1(&quot;Exiting due to command-line parsing error.\n&quot;, Err1);
  }

  config-&gt;arg_count = num_feature_args;
  config-&gt;args = (FeatureArg*)calloc(num_feature_args, sizeof(*config-&gt;args));
  if (config-&gt;args == NULL) {
    ERROR_GOTO1(&quot;ERROR: Memory allocation error.\n&quot;, Err1);
  }

  // Parse command-line.
  if (!ParseCommandLine(config, unicode_argv) || !ValidateConfig(config)) {
    ERROR_GOTO1(&quot;Exiting due to command-line parsing error.\n&quot;, Err1);
  }

Err1:
  return ok;
}

#undef ACTION_IS_NIL
#undef FEATURETYPE_IS_NIL
#undef CHECK_NUM_ARGS_AT_LEAST
#undef CHECK_NUM_ARGS_AT_MOST
#undef CHECK_NUM_ARGS_EXACTLY

//------------------------------------------------------------------------------
// Processing.

static int GetFrame(const WebPMux* mux, const Config* config) {
  WebPMuxError err = WEBP_MUX_OK;
  WebPMux* mux_single = NULL;
  int num = 0;
  int ok = 1;
  int parse_error = 0;
  const WebPChunkId id = WEBP_CHUNK_ANMF;
  WebPMuxFrameInfo info;
  WebPDataInit(&amp;info.bitstream);

  num = ExUtilGetInt(config-&gt;args[0].params, 10, &amp;parse_error);
  if (num &lt; 0) {
    ERROR_GOTO1(&quot;ERROR: Frame/Fragment index must be non-negative.\n&quot;, ErrGet);
  }
  if (parse_error) goto ErrGet;

  err = WebPMuxGetFrame(mux, num, &amp;info);
  if (err == WEBP_MUX_OK &amp;&amp; info.id != id) err = WEBP_MUX_NOT_FOUND;
  if (err != WEBP_MUX_OK) {
    ERROR_GOTO3(&quot;ERROR (%s): Could not get frame %d.\n&quot;, ErrorString(err), num,
                ErrGet);
  }

  mux_single = WebPMuxNew();
  if (mux_single == NULL) {
    err = WEBP_MUX_MEMORY_ERROR;
    ERROR_GOTO2(&quot;ERROR (%s): Could not allocate a mux object.\n&quot;,
                ErrorString(err), ErrGet);
  }
  err = WebPMuxSetImage(mux_single, &amp;info.bitstream, 1);
  if (err != WEBP_MUX_OK) {
    ERROR_GOTO2(&quot;ERROR (%s): Could not create single image mux object.\n&quot;,
                ErrorString(err), ErrGet);
  }

  ok = WriteWebP(mux_single, config-&gt;output);

ErrGet:
  WebPDataClear(&amp;info.bitstream);
  WebPMuxDelete(mux_single);
  return ok &amp;&amp; !parse_error;
}

// Read and process config.
static int Process(const Config* config) {
  WebPMux* mux = NULL;
  WebPData chunk;
  WebPMuxError err = WEBP_MUX_OK;
  int ok = 1;

  switch (config-&gt;action_type) {
    case ACTION_GET: {
      ok = CreateMux(config-&gt;input, &amp;mux);
      if (!ok) goto Err2;
      switch (config-&gt;type) {
        case FEATURE_ANMF:
          ok = GetFrame(mux, config);
          break;

        case FEATURE_ICCP:
        case FEATURE_EXIF:
        case FEATURE_XMP:
          err = WebPMuxGetChunk(mux, kFourccList[config-&gt;type], &amp;chunk);
          if (err != WEBP_MUX_OK) {
            ERROR_GOTO3(&quot;ERROR (%s): Could not get the %s.\n&quot;, ErrorString(err),
                        kDescriptions[config-&gt;type], Err2);
          }
          ok = WriteData(config-&gt;output, &amp;chunk);
          break;

        default:
          ERROR_GOTO1(&quot;ERROR: Invalid feature for action &#039;get&#039;.\n&quot;, Err2);
          break;
      }
      break;
    }
    case ACTION_SET: {
      switch (config-&gt;type) {
        case FEATURE_ANMF: {
          int i;
          WebPMuxAnimParams params = {0xFFFFFFFF, 0};
          mux = WebPMuxNew();
          if (mux == NULL) {
            ERROR_GOTO2(&quot;ERROR (%s): Could not allocate a mux object.\n&quot;,
                        ErrorString(WEBP_MUX_MEMORY_ERROR), Err2);
          }
          for (i = 0; i &lt; config-&gt;arg_count; ++i) {
            switch (config-&gt;args[i].subtype) {
              case SUBTYPE_BGCOLOR: {
                uint32_t bgcolor;
                ok = ParseBgcolorArgs(config-&gt;args[i].params, &amp;bgcolor);
                if (!ok) {
                  ERROR_GOTO1(&quot;ERROR: Could not parse the background color \n&quot;,
                              Err2);
                }
                params.bgcolor = bgcolor;
                break;
              }
              case SUBTYPE_LOOP: {
                int parse_error = 0;
                const int loop_count =
                    ExUtilGetInt(config-&gt;args[i].params, 10, &amp;parse_error);
                if (loop_count &lt; 0 || loop_count &gt; 65535) {
                  // Note: This is only a &#039;necessary&#039; condition for loop_count
                  // to be valid. The &#039;sufficient&#039; conditioned in checked in
                  // WebPMuxSetAnimationParams() method called later.
                  ERROR_GOTO1(
                      &quot;ERROR: Loop count must be in the range 0 to &quot;
                      &quot;65535.\n&quot;,
                      Err2);
                }
                ok = !parse_error;
                if (!ok) goto Err2;
                params.loop_count = loop_count;
                break;
              }
              case SUBTYPE_ANMF: {
                WebPMuxFrameInfo frame;
                frame.id = WEBP_CHUNK_ANMF;
                ok = ExUtilReadFileToWebPData(config-&gt;args[i].filename,
                                              &amp;frame.bitstream);
                if (!ok) goto Err2;
                ok = ParseFrameArgs(config-&gt;args[i].params, &amp;frame);
                if (!ok) {
                  WebPDataClear(&amp;frame.bitstream);
                  ERROR_GOTO1(&quot;ERROR: Could not parse frame properties.\n&quot;,
                              Err2);
                }
                err = WebPMuxPushFrame(mux, &amp;frame, 1);
                WebPDataClear(&amp;frame.bitstream);
                if (err != WEBP_MUX_OK) {
                  ERROR_GOTO3(
                      &quot;ERROR (%s): Could not add a frame at index %d.&quot;
                      &quot;\n&quot;,
                      ErrorString(err), i, Err2);
                }
                break;
              }
              default: {
                ERROR_GOTO1(&quot;ERROR: Invalid subtype for &#039;frame&#039;&quot;, Err2);
                break;
              }
            }
          }
          err = WebPMuxSetAnimationParams(mux, &amp;params);
          if (err != WEBP_MUX_OK) {
            ERROR_GOTO2(&quot;ERROR (%s): Could not set animation parameters.\n&quot;,
                        ErrorString(err), Err2);
          }
          break;
        }

        case FEATURE_ICCP:
        case FEATURE_EXIF:
        case FEATURE_XMP: {
          ok = CreateMux(config-&gt;input, &amp;mux);
          if (!ok) goto Err2;
          ok = ExUtilReadFileToWebPData(config-&gt;args[0].filename, &amp;chunk);
          if (!ok) goto Err2;
          err = WebPMuxSetChunk(mux, kFourccList[config-&gt;type], &amp;chunk, 1);
          WebPDataClear(&amp;chunk);
          if (err != WEBP_MUX_OK) {
            ERROR_GOTO3(&quot;ERROR (%s): Could not set the %s.\n&quot;, ErrorString(err),
                        kDescriptions[config-&gt;type], Err2);
          }
          break;
        }
        case FEATURE_LOOP: {
          WebPMuxAnimParams params = {0xFFFFFFFF, 0};
          int parse_error = 0;
          const int loop_count =
              ExUtilGetInt(config-&gt;args[0].params, 10, &amp;parse_error);
          if (loop_count &lt; 0 || loop_count &gt; 65535 || parse_error) {
            ERROR_GOTO1(&quot;ERROR: Loop count must be in the range 0 to 65535.\n&quot;,
                        Err2);
          }
          ok = CreateMux(config-&gt;input, &amp;mux);
          if (!ok) goto Err2;
          ok = (WebPMuxGetAnimationParams(mux, &amp;params) == WEBP_MUX_OK);
          if (!ok) {
            ERROR_GOTO1(&quot;ERROR: input file does not seem to be an animation.\n&quot;,
                        Err2);
          }
          params.loop_count = loop_count;
          err = WebPMuxSetAnimationParams(mux, &amp;params);
          ok = (err == WEBP_MUX_OK);
          if (!ok) {
            ERROR_GOTO2(&quot;ERROR (%s): Could not set animation parameters.\n&quot;,
                        ErrorString(err), Err2);
          }
          break;
        }
        case FEATURE_BGCOLOR: {
          WebPMuxAnimParams params = {0xFFFFFFFF, 0};
          uint32_t bgcolor;
          ok = ParseBgcolorArgs(config-&gt;args[0].params, &amp;bgcolor);
          if (!ok) {
            ERROR_GOTO1(&quot;ERROR: Could not parse the background color.\n&quot;, Err2);
          }
          ok = CreateMux(config-&gt;input, &amp;mux);
          if (!ok) goto Err2;
          ok = (WebPMuxGetAnimationParams(mux, &amp;params) == WEBP_MUX_OK);
          if (!ok) {
            ERROR_GOTO1(&quot;ERROR: input file does not seem to be an animation.\n&quot;,
                        Err2);
          }
          params.bgcolor = bgcolor;
          err = WebPMuxSetAnimationParams(mux, &amp;params);
          ok = (err == WEBP_MUX_OK);
          if (!ok) {
            ERROR_GOTO2(&quot;ERROR (%s): Could not set animation parameters.\n&quot;,
                        ErrorString(err), Err2);
          }
          break;
        }
        default: {
          ERROR_GOTO1(&quot;ERROR: Invalid feature for action &#039;set&#039;.\n&quot;, Err2);
          break;
        }
      }
      ok = WriteWebP(mux, config-&gt;output);
      break;
    }
    case ACTION_DURATION: {
      int num_frames;
      ok = CreateMux(config-&gt;input, &amp;mux);
      if (!ok) goto Err2;
      err = WebPMuxNumChunks(mux, WEBP_CHUNK_ANMF, &amp;num_frames);
      ok = (err == WEBP_MUX_OK);
      if (!ok) {
        ERROR_GOTO1(&quot;ERROR: can not parse the number of frames.\n&quot;, Err2);
      }
      if (num_frames == 0) {
        fprintf(stderr,
                &quot;Doesn&#039;t look like the source is animated. &quot;
                &quot;Skipping duration setting.\n&quot;);
        ok = WriteWebP(mux, config-&gt;output);
        if (!ok) goto Err2;
      } else {
        int i;
        int* durations = NULL;
        WebPMux* new_mux = DuplicateMuxHeader(mux);
        if (new_mux == NULL) goto Err2;
        durations = (int*)WebPMalloc((size_t)num_frames * sizeof(*durations));
        if (durations == NULL) goto Err2;
        for (i = 0; i &lt; num_frames; ++i) durations[i] = -1;

        // Parse intervals to process.
        for (i = 0; i &lt; config-&gt;arg_count; ++i) {
          int k;
          int args[3];
          int duration, start, end;
          const int nb_args =
              ExUtilGetInts(config-&gt;args[i].params, 10, 3, args);
          ok = (nb_args &gt;= 1);
          if (!ok) goto Err3;
          duration = args[0];
          if (duration &lt; 0) {
            ERROR_GOTO1(&quot;ERROR: duration must be strictly positive.\n&quot;, Err3);
          }

          if (nb_args == 1) {  // only duration is present -&gt; use full interval
            start = 1;
            end = num_frames;
          } else {
            start = args[1];
            if (start &lt;= 0) {
              start = 1;
            } else if (start &gt; num_frames) {
              start = num_frames;
            }
            end = (nb_args &gt;= 3) ? args[2] : start;
            if (end == 0 || end &gt; num_frames) end = num_frames;
          }

          for (k = start; k &lt;= end; ++k) {
            assert(k &gt;= 1 &amp;&amp; k &lt;= num_frames);
            durations[k - 1] = duration;
          }
        }

        // Apply non-negative durations to their destination frames.
        for (i = 1; i &lt;= num_frames; ++i) {
          WebPMuxFrameInfo frame;
          err = WebPMuxGetFrame(mux, i, &amp;frame);
          if (err != WEBP_MUX_OK || frame.id != WEBP_CHUNK_ANMF) {
            ERROR_GOTO2(&quot;ERROR: can not retrieve frame #%d.\n&quot;, i, Err3);
          }
          if (durations[i - 1] &gt;= 0) frame.duration = durations[i - 1];
          err = WebPMuxPushFrame(new_mux, &amp;frame, 1);
          if (err != WEBP_MUX_OK) {
            ERROR_GOTO2(&quot;ERROR: error push frame data #%d\n&quot;, i, Err3);
          }
          WebPDataClear(&amp;frame.bitstream);
        }
        WebPMuxDelete(mux);
        ok = WriteWebP(new_mux, config-&gt;output);
        mux = new_mux;  // transfer for the WebPMuxDelete() call
        new_mux = NULL;

      Err3:
        WebPFree(durations);
        WebPMuxDelete(new_mux);
        if (!ok) goto Err2;
      }
      break;
    }
    case ACTION_STRIP: {
      ok = CreateMux(config-&gt;input, &amp;mux);
      if (!ok) goto Err2;
      if (config-&gt;type == FEATURE_ICCP || config-&gt;type == FEATURE_EXIF ||
          config-&gt;type == FEATURE_XMP) {
        err = WebPMuxDeleteChunk(mux, kFourccList[config-&gt;type]);
        if (err != WEBP_MUX_OK) {
          ERROR_GOTO3(&quot;ERROR (%s): Could not strip the %s.\n&quot;, ErrorString(err),
                      kDescriptions[config-&gt;type], Err2);
        }
      } else {
        ERROR_GOTO1(&quot;ERROR: Invalid feature for action &#039;strip&#039;.\n&quot;, Err2);
        break;
      }
      ok = WriteWebP(mux, config-&gt;output);
      break;
    }
    case ACTION_INFO: {
      ok = CreateMux(config-&gt;input, &amp;mux);
      if (!ok) goto Err2;
      ok = (DisplayInfo(mux) == WEBP_MUX_OK);
      break;
    }
    default: {
      assert(0);  // Invalid action.
      break;
    }
  }

Err2:
  WebPMuxDelete(mux);
  return ok;
}

//------------------------------------------------------------------------------
// Main.

// Returns EXIT_SUCCESS on success, EXIT_FAILURE on failure.
int main(int argc, const char* argv[]) {
  Config config;
  int ok;

  INIT_WARGV(argc, argv);

  ok = InitializeConfig(argc - 1, argv + 1, &amp;config, GET_WARGV_OR_NULL());
  if (ok) {
    ok = Process(&amp;config);
  } else {
    PrintHelp();
  }
  DeleteConfig(&amp;config);
  FREE_WARGV_AND_RETURN(ok ? EXIT_SUCCESS : EXIT_FAILURE);
}

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