�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Flibwebp%2F'>libwebp</a>/<a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fsrc%2F'>src</a>/<a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fsrc%2Fdec%2F'>dec</a>/</p><hr><h3>✏️ Editing: alpha_dec.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.
// -----------------------------------------------------------------------------
//
// Alpha-plane decompression.
//
// Author: Skal (pascal.massimino@gmail.com)

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

#include &quot;src/dec/alphai_dec.h&quot;
#include &quot;src/dec/vp8_dec.h&quot;
#include &quot;src/dec/vp8i_dec.h&quot;
#include &quot;src/dec/vp8li_dec.h&quot;
#include &quot;src/dec/webpi_dec.h&quot;
#include &quot;src/dsp/dsp.h&quot;
#include &quot;src/utils/quant_levels_dec_utils.h&quot;
#include &quot;src/utils/utils.h&quot;
#include &quot;src/webp/decode.h&quot;
#include &quot;src/webp/format_constants.h&quot;
#include &quot;src/webp/types.h&quot;

WEBP_ASSUME_UNSAFE_INDEXABLE_ABI

//------------------------------------------------------------------------------
// ALPHDecoder object.

// Allocates a new alpha decoder instance.
WEBP_NODISCARD static ALPHDecoder* ALPHNew(void) {
  ALPHDecoder* const dec = (ALPHDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
  return dec;
}

// Clears and deallocates an alpha decoder instance.
static void ALPHDelete(ALPHDecoder* const dec) {
  if (dec != NULL) {
    VP8LDelete(dec-&gt;vp8l_dec);
    dec-&gt;vp8l_dec = NULL;
    WebPSafeFree(dec);
  }
}

//------------------------------------------------------------------------------
// Decoding.

// Initialize alpha decoding by parsing the alpha header and decoding the image
// header for alpha data stored using lossless compression.
// Returns VP8_STATUS_OK on success, the reason for the failure otherwise
// (data too short, invalid compression method or filter, error in the
// lossless header data, etc.).
WEBP_NODISCARD static VP8StatusCode ALPHInit(ALPHDecoder* const dec,
                                             const uint8_t* data,
                                             size_t data_size,
                                             const VP8Io* const src_io,
                                             uint8_t* output) {
  VP8StatusCode status;
  const uint8_t* const alpha_data = data + ALPHA_HEADER_LEN;
  int rsrv;
  VP8Io* const io = &amp;dec-&gt;io;

  assert(data != NULL &amp;&amp; output != NULL &amp;&amp; src_io != NULL);

  VP8FiltersInit();
  dec-&gt;output = output;
  dec-&gt;width = src_io-&gt;width;
  dec-&gt;height = src_io-&gt;height;
  assert(dec-&gt;width &gt; 0 &amp;&amp; dec-&gt;height &gt; 0);

  if (data_size &lt;= ALPHA_HEADER_LEN) {
    return VP8_STATUS_BITSTREAM_ERROR;
  }

  dec-&gt;method = (data[0] &gt;&gt; 0) &amp; 0x03;
  dec-&gt;filter = (WEBP_FILTER_TYPE)((data[0] &gt;&gt; 2) &amp; 0x03);
  dec-&gt;pre_processing = (data[0] &gt;&gt; 4) &amp; 0x03;
  rsrv = (data[0] &gt;&gt; 6) &amp; 0x03;
  if (dec-&gt;method &lt; ALPHA_NO_COMPRESSION ||
      dec-&gt;method &gt; ALPHA_LOSSLESS_COMPRESSION ||
      dec-&gt;filter &gt;= WEBP_FILTER_LAST ||
      dec-&gt;pre_processing &gt; ALPHA_PREPROCESSED_LEVELS || rsrv != 0) {
    return VP8_STATUS_BITSTREAM_ERROR;
  }

  // Copy the necessary parameters from src_io to io
  if (!VP8InitIo(io)) {
    return VP8_STATUS_INVALID_PARAM;
  }
  WebPInitCustomIo(NULL, io);
  io-&gt;opaque = dec;
  io-&gt;width = src_io-&gt;width;
  io-&gt;height = src_io-&gt;height;

  io-&gt;use_cropping = src_io-&gt;use_cropping;
  io-&gt;crop_left = src_io-&gt;crop_left;
  io-&gt;crop_right = src_io-&gt;crop_right;
  io-&gt;crop_top = src_io-&gt;crop_top;
  io-&gt;crop_bottom = src_io-&gt;crop_bottom;
  // No need to copy the scaling parameters.

  {
    const size_t alpha_data_size = data_size - ALPHA_HEADER_LEN;
    if (dec-&gt;method == ALPHA_NO_COMPRESSION) {
      const size_t alpha_decoded_size = dec-&gt;width * dec-&gt;height;
      status = (alpha_data_size &gt;= alpha_decoded_size)
                   ? VP8_STATUS_OK
                   : VP8_STATUS_BITSTREAM_ERROR;
    } else {
      assert(dec-&gt;method == ALPHA_LOSSLESS_COMPRESSION);
      {
        const uint8_t* WEBP_BIDI_INDEXABLE const bounded_alpha_data =
            WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(const uint8_t*, alpha_data,
                                             alpha_data_size);
        status =
            VP8LDecodeAlphaHeader(dec, bounded_alpha_data, alpha_data_size);
      }
    }
  }

  return status;
}

// Decodes, unfilters and dequantizes *at least* &#039;num_rows&#039; rows of alpha
// starting from row number &#039;row&#039;. It assumes that rows up to (row - 1) have
// already been decoded.
// Returns false in case of bitstream error.
WEBP_NODISCARD static int ALPHDecode(VP8Decoder* const dec, int row,
                                     int num_rows) {
  ALPHDecoder* const alph_dec = dec-&gt;alph_dec;
  const int width = alph_dec-&gt;width;
  const int height = alph_dec-&gt;io.crop_bottom;
  if (alph_dec-&gt;method == ALPHA_NO_COMPRESSION) {
    int y;
    const uint8_t* prev_line = dec-&gt;alpha_prev_line;
    const uint8_t* deltas = dec-&gt;alpha_data + ALPHA_HEADER_LEN + row * width;
    uint8_t* dst = dec-&gt;alpha_plane + row * width;
    assert(deltas &lt;= &amp;dec-&gt;alpha_data[dec-&gt;alpha_data_size]);
    assert(WebPUnfilters[alph_dec-&gt;filter] != NULL);
    for (y = 0; y &lt; num_rows; ++y) {
      WebPUnfilters[alph_dec-&gt;filter](prev_line, deltas, dst, width);
      prev_line = dst;
      dst += width;
      deltas += width;
    }
    dec-&gt;alpha_prev_line = prev_line;
  } else {  // alph_dec-&gt;method == ALPHA_LOSSLESS_COMPRESSION
    assert(alph_dec-&gt;vp8l_dec != NULL);
    if (!VP8LDecodeAlphaImageStream(alph_dec, row + num_rows)) {
      // SUSPENDED means truncated, but the ALPH chunk is whole by now.
      const VP8StatusCode status = alph_dec-&gt;vp8l_dec-&gt;status;
      return VP8SetError(dec,
                         (status == VP8_STATUS_SUSPENDED)
                             ? VP8_STATUS_BITSTREAM_ERROR
                             : status,
                         &quot;Could not decode alpha data.&quot;);
    }
  }

  if (row + num_rows &gt;= height) {
    dec-&gt;is_alpha_decoded = 1;
  }
  return 1;
}

WEBP_NODISCARD static int AllocateAlphaPlane(VP8Decoder* const dec,
                                             const VP8Io* const io) {
  const int stride = io-&gt;width;
  const int height = io-&gt;crop_bottom;
  const uint64_t alpha_size = (uint64_t)stride * height;
  assert(dec-&gt;alpha_plane_mem == NULL);
  dec-&gt;alpha_plane_mem =
      (uint8_t*)WebPSafeMalloc(alpha_size, sizeof(*dec-&gt;alpha_plane));
  if (dec-&gt;alpha_plane_mem == NULL) {
    return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
                       &quot;Alpha decoder initialization failed.&quot;);
  }
  dec-&gt;alpha_plane = dec-&gt;alpha_plane_mem;
  dec-&gt;alpha_prev_line = NULL;
  return 1;
}

void WebPDeallocateAlphaMemory(VP8Decoder* const dec) {
  assert(dec != NULL);
  WebPSafeFree(dec-&gt;alpha_plane_mem);
  dec-&gt;alpha_plane_mem = NULL;
  dec-&gt;alpha_plane = NULL;
  ALPHDelete(dec-&gt;alph_dec);
  dec-&gt;alph_dec = NULL;
}

//------------------------------------------------------------------------------
// Main entry point.

WEBP_NODISCARD const uint8_t* VP8DecompressAlphaRows(VP8Decoder* const dec,
                                                     const VP8Io* const io,
                                                     int row, int num_rows) {
  const int width = io-&gt;width;
  const int height = io-&gt;crop_bottom;

  assert(dec != NULL &amp;&amp; io != NULL);

  if (row &lt; 0 || num_rows &lt;= 0 || row + num_rows &gt; height) {
    return NULL;
  }

  if (!dec-&gt;is_alpha_decoded) {
    if (dec-&gt;alph_dec == NULL) {  // Initialize decoder.
      dec-&gt;alph_dec = ALPHNew();
      if (dec-&gt;alph_dec == NULL) {
        VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
                    &quot;Alpha decoder initialization failed.&quot;);
        return NULL;
      }
      if (!AllocateAlphaPlane(dec, io)) goto Error;
      {
        const VP8StatusCode status =
            ALPHInit(dec-&gt;alph_dec, dec-&gt;alpha_data, dec-&gt;alpha_data_size, io,
                     dec-&gt;alpha_plane);
        if (status != VP8_STATUS_OK) {
          VP8SetError(dec, status, &quot;Alpha decoder initialization failed.&quot;);
          goto Error;
        }
      }
      // if we allowed use of alpha dithering, check whether it&#039;s needed at all
      if (dec-&gt;alph_dec-&gt;pre_processing != ALPHA_PREPROCESSED_LEVELS) {
        dec-&gt;alpha_dithering = 0;  // disable dithering
      } else {
        num_rows = height - row;  // decode everything in one pass
      }
    }

    assert(dec-&gt;alph_dec != NULL);
    assert(row + num_rows &lt;= height);
    if (!ALPHDecode(dec, row, num_rows)) goto Error;

    if (dec-&gt;is_alpha_decoded) {  // finished?
      ALPHDelete(dec-&gt;alph_dec);
      dec-&gt;alph_dec = NULL;
      if (dec-&gt;alpha_dithering &gt; 0) {
        uint8_t* const alpha =
            dec-&gt;alpha_plane + io-&gt;crop_top * width + io-&gt;crop_left;
        uint8_t* WEBP_BIDI_INDEXABLE const bounded_alpha =
            WEBP_UNSAFE_FORGE_BIDI_INDEXABLE(
                uint8_t*, alpha,
                (size_t)width*(io-&gt;crop_bottom - io-&gt;crop_top));
        if (!WebPDequantizeLevels(bounded_alpha, io-&gt;crop_right - io-&gt;crop_left,
                                  io-&gt;crop_bottom - io-&gt;crop_top, width,
                                  dec-&gt;alpha_dithering)) {
          // Dimensions and strength are checked upstream: only the scratch
          // buffer can fail.
          VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
                      &quot;no memory for alpha dithering.&quot;);
          goto Error;
        }
      }
    }
  }

  // Return a pointer to the current decoded row.
  return dec-&gt;alpha_plane + row * width;

Error:
  WebPDeallocateAlphaMemory(dec);
  return NULL;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Flibwebp%2Fsrc%2Fdec'>🔙 Back</a></p>