�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%2Fimageio%2F'>imageio</a>/</p><hr><h3>✏️ Editing: webpdec.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>// Copyright 2014 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be found in the AUTHORS file in the root of the source tree.
// -----------------------------------------------------------------------------
//
// WebP decode.

#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 &quot;../examples/unicode.h&quot;
#include &quot;./imageio_util.h&quot;
#include &quot;./metadata.h&quot;
#include &quot;./webpdec.h&quot;
#include &quot;webp/decode.h&quot;
#include &quot;webp/demux.h&quot;
#include &quot;webp/encode.h&quot;
#include &quot;webp/mux_types.h&quot;
#include &quot;webp/types.h&quot;

//------------------------------------------------------------------------------
// WebP decoding

static const char* const kStatusMessages[VP8_STATUS_NOT_ENOUGH_DATA + 1] = {
    &quot;OK&quot;,
    &quot;OUT_OF_MEMORY&quot;,
    &quot;INVALID_PARAM&quot;,
    &quot;BITSTREAM_ERROR&quot;,
    &quot;UNSUPPORTED_FEATURE&quot;,
    &quot;SUSPENDED&quot;,
    &quot;USER_ABORT&quot;,
    &quot;NOT_ENOUGH_DATA&quot;};

static void PrintAnimationWarning(const WebPDecoderConfig* const config) {
  if (config-&gt;input.has_animation) {
    fprintf(stderr,
            &quot;Error! Decoding of an animated WebP file is not supported.\n&quot;
            &quot;       Use webpmux to extract the individual frames or\n&quot;
            &quot;       vwebp to view this image.\n&quot;);
  }
}

void PrintWebPError(const char* const in_file, int status) {
  WFPRINTF(stderr, &quot;Decoding of %s failed.\n&quot;, (const W_CHAR*)in_file);
  fprintf(stderr, &quot;Status: %d&quot;, status);
  if (status &gt;= VP8_STATUS_OK &amp;&amp; status &lt;= VP8_STATUS_NOT_ENOUGH_DATA) {
    fprintf(stderr, &quot;(%s)&quot;, kStatusMessages[status]);
  }
  fprintf(stderr, &quot;\n&quot;);
}

int LoadWebP(const char* const in_file, const uint8_t** data, size_t* data_size,
             WebPBitstreamFeatures* bitstream) {
  VP8StatusCode status;
  WebPBitstreamFeatures local_features;
  if (!ImgIoUtilReadFile(in_file, data, data_size)) return 0;

  if (bitstream == NULL) {
    bitstream = &amp;local_features;
  }

  status = WebPGetFeatures(*data, *data_size, bitstream);
  if (status != VP8_STATUS_OK) {
    WebPFree((void*)*data);
    *data = NULL;
    *data_size = 0;
    PrintWebPError(in_file, status);
    return 0;
  }
  return 1;
}

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

VP8StatusCode DecodeWebP(const uint8_t* const data, size_t data_size,
                         WebPDecoderConfig* const config) {
  if (config == NULL) return VP8_STATUS_INVALID_PARAM;
  PrintAnimationWarning(config);
  return WebPDecode(data, data_size, config);
}

VP8StatusCode DecodeWebPIncremental(const uint8_t* const data, size_t data_size,
                                    WebPDecoderConfig* const config) {
  VP8StatusCode status = VP8_STATUS_OK;
  if (config == NULL) return VP8_STATUS_INVALID_PARAM;

  PrintAnimationWarning(config);

  // Decoding call.
  {
    WebPIDecoder* const idec = WebPIDecode(data, data_size, config);
    if (idec == NULL) {
      fprintf(stderr, &quot;Failed during WebPIDecode().\n&quot;);
      return VP8_STATUS_OUT_OF_MEMORY;
    } else {
      status = WebPIUpdate(idec, data, data_size);
      WebPIDelete(idec);
    }
  }
  return status;
}

// -----------------------------------------------------------------------------
// Metadata

static int ExtractMetadata(const uint8_t* const data, size_t data_size,
                           Metadata* const metadata) {
  WebPData webp_data = {data, data_size};
  WebPDemuxer* const demux = WebPDemux(&amp;webp_data);
  WebPChunkIterator chunk_iter;
  uint32_t flags;

  if (demux == NULL) return 0;
  assert(metadata != NULL);

  flags = WebPDemuxGetI(demux, WEBP_FF_FORMAT_FLAGS);

  if ((flags &amp; ICCP_FLAG) &amp;&amp; WebPDemuxGetChunk(demux, &quot;ICCP&quot;, 1, &amp;chunk_iter)) {
    MetadataCopy((const char*)chunk_iter.chunk.bytes, chunk_iter.chunk.size,
                 &amp;metadata-&gt;iccp);
    WebPDemuxReleaseChunkIterator(&amp;chunk_iter);
  }
  if ((flags &amp; EXIF_FLAG) &amp;&amp; WebPDemuxGetChunk(demux, &quot;EXIF&quot;, 1, &amp;chunk_iter)) {
    MetadataCopy((const char*)chunk_iter.chunk.bytes, chunk_iter.chunk.size,
                 &amp;metadata-&gt;exif);
    WebPDemuxReleaseChunkIterator(&amp;chunk_iter);
  }
  if ((flags &amp; XMP_FLAG) &amp;&amp; WebPDemuxGetChunk(demux, &quot;XMP &quot;, 1, &amp;chunk_iter)) {
    MetadataCopy((const char*)chunk_iter.chunk.bytes, chunk_iter.chunk.size,
                 &amp;metadata-&gt;xmp);
    WebPDemuxReleaseChunkIterator(&amp;chunk_iter);
  }
  WebPDemuxDelete(demux);
  return 1;
}

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

int ReadWebP(const uint8_t* const data, size_t data_size,
             WebPPicture* const pic, int keep_alpha, Metadata* const metadata) {
  int ok = 0;
  VP8StatusCode status = VP8_STATUS_OK;
  WebPDecoderConfig config;
  WebPDecBuffer* const output_buffer = &amp;config.output;
  WebPBitstreamFeatures* const bitstream = &amp;config.input;

  if (data == NULL || data_size == 0 || pic == NULL) return 0;

  if (!WebPInitDecoderConfig(&amp;config)) {
    fprintf(stderr, &quot;Library version mismatch!\n&quot;);
    return 0;
  }

  status = WebPGetFeatures(data, data_size, bitstream);
  if (status != VP8_STATUS_OK) {
    PrintWebPError(&quot;input data&quot;, status);
    return 0;
  }

  do {
    const int has_alpha = keep_alpha &amp;&amp; bitstream-&gt;has_alpha;
    uint64_t stride;
    pic-&gt;width = bitstream-&gt;width;
    pic-&gt;height = bitstream-&gt;height;
    if (pic-&gt;use_argb) {
      stride = (uint64_t)bitstream-&gt;width * 4;
    } else {
      stride = (uint64_t)bitstream-&gt;width * (has_alpha ? 5 : 3) / 2;
      pic-&gt;colorspace = has_alpha ? WEBP_YUV420A : WEBP_YUV420;
    }

    if (!ImgIoUtilCheckSizeArgumentsOverflow(stride, bitstream-&gt;height)) {
      status = VP8_STATUS_OUT_OF_MEMORY;
      break;
    }

    ok = WebPPictureAlloc(pic);
    if (!ok) {
      status = VP8_STATUS_OUT_OF_MEMORY;
      break;
    }
    if (pic-&gt;use_argb) {
#ifdef WORDS_BIGENDIAN
      output_buffer-&gt;colorspace = MODE_ARGB;
#else
      output_buffer-&gt;colorspace = MODE_BGRA;
#endif
      output_buffer-&gt;u.RGBA.rgba = (uint8_t*)pic-&gt;argb;
      output_buffer-&gt;u.RGBA.stride = pic-&gt;argb_stride * sizeof(uint32_t);
      output_buffer-&gt;u.RGBA.size =
          (size_t)output_buffer-&gt;u.RGBA.stride * pic-&gt;height;
    } else {
      output_buffer-&gt;colorspace = has_alpha ? MODE_YUVA : MODE_YUV;
      output_buffer-&gt;u.YUVA.y = pic-&gt;y;
      output_buffer-&gt;u.YUVA.u = pic-&gt;u;
      output_buffer-&gt;u.YUVA.v = pic-&gt;v;
      output_buffer-&gt;u.YUVA.a = has_alpha ? pic-&gt;a : NULL;
      output_buffer-&gt;u.YUVA.y_stride = pic-&gt;y_stride;
      output_buffer-&gt;u.YUVA.u_stride = pic-&gt;uv_stride;
      output_buffer-&gt;u.YUVA.v_stride = pic-&gt;uv_stride;
      output_buffer-&gt;u.YUVA.a_stride = has_alpha ? pic-&gt;a_stride : 0;
      output_buffer-&gt;u.YUVA.y_size = (size_t)pic-&gt;height * pic-&gt;y_stride;
      output_buffer-&gt;u.YUVA.u_size =
          (size_t)(pic-&gt;height + 1) / 2 * pic-&gt;uv_stride;
      output_buffer-&gt;u.YUVA.v_size =
          (size_t)(pic-&gt;height + 1) / 2 * pic-&gt;uv_stride;
      output_buffer-&gt;u.YUVA.a_size = (size_t)pic-&gt;height * pic-&gt;a_stride;
    }
    output_buffer-&gt;is_external_memory = 1;

    status = DecodeWebP(data, data_size, &amp;config);
    ok = (status == VP8_STATUS_OK);
    if (ok &amp;&amp; !keep_alpha &amp;&amp; pic-&gt;use_argb) {
      // Need to wipe out the alpha value, as requested.
      int x, y;
      uint32_t* argb = pic-&gt;argb;
      for (y = 0; y &lt; pic-&gt;height; ++y) {
        for (x = 0; x &lt; pic-&gt;width; ++x) argb[x] |= 0xff000000u;
        argb += pic-&gt;argb_stride;
      }
    }
  } while (0);  // &lt;- so we can &#039;break&#039; out of the loop

  if (status != VP8_STATUS_OK) {
    PrintWebPError(&quot;input data&quot;, status);
    ok = 0;
  }

  WebPFreeDecBuffer(output_buffer);

  if (ok &amp;&amp; metadata != NULL) {
    ok = ExtractMetadata(data, data_size, metadata);
    if (!ok) {
      PrintWebPError(&quot;metadata&quot;, VP8_STATUS_BITSTREAM_ERROR);
    }
  }
  if (!ok) WebPPictureFree(pic);
  return ok;
}

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