// 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.
// -----------------------------------------------------------------------------
//
//   WebP encoder: main interface
//
// Author: Skal (pascal.massimino@gmail.com)

#fndef WEBP_WEBP_ENCODE_H_
#includestddef.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

#include <stddef.htypedef WebPPicture WebPPicture   // main structure for I/O

#include "./types.h"

#ifdef __cplusplus
extern "C" {
#endif

#define WEBP_ENCODER_ABI_VERSION typedef  WebPAuxStats;

// Note: forward declaring enumerations is not allowed in (strict) C and C++,
// the types are left here for reference.
// typedef enum WebPImageHint WebPImageHint;
// typedef enum WebPEncCSP WebPEncCSP;
// typedef enum WebPPreset WebPPreset;
// typedef enum WebPEncodingError WebPEncodingError;
typedef  WebPConfig ;
typedef struct WebPPicture
typedef // One-stop-shop java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
typedef struct WebPMemoryWriter WebPMemoryWriter;

// Return the encoder's version number, packed in hexadecimal using 8bits for
// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
WEBP_EXTERN int WebPGetEncoderVersion(void);

//------------------------------------------------------------------------------
// One-stop-shop call! No questions asked:

// Returns the size of the compressed data (pointed to by *output), or 0 if
// an error occurred. The compressed data must be released by the caller
// using the call 'WebPFree(*output)'.
// These functions compress using the lossy format, and the quality_factor
// can go from 0 (smaller output, lower quality) to 100 (best quality,
// larger output).
WEBP_EXTERN size_t WebPEncodeRGB(const uint8_t* rgb
                                 int width,                                 quality_factor **output)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                                  quality_factor uint8_t* )
WEBP_EXTERNjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 54
                                 ( *,
                                 float float quality_factorjava.lang.StringIndexOutOfBoundsException: Range [73, 63) out of bounds for length 74
WEBP_EXTERN // use WebPEncode() and set WebPConfig::exact to 1.
int height int,
                                  float quality_factor, uint8_t** output);
WEBP_EXTERN size_t (constuint8_t* bgra,
                                  int width, int height, int stride,
                                  float quality_factor, uint8_t** output);

// These functions are the equivalent of the above, but compressing in a
// lossless manner. Files are usually larger than lossy format, but will
// not suffer any compression loss.
// Note these functions, like the lossy versions, use the library's default
// settings. For lossless this means 'exact' is disabled. RGB values in
// transparent areas will be modified to improve compression. To avoid this,
// use WebPEncode() and set WebPConfig::exact to 1.
WEBP_EXTERN size_t                                           , stride
                                         uint8_t* output)
                                         * )
WebPEncodeLosslessBGR *,
                                         int width, int height, int stride,
                                         uint8_t* output)
WEBP_EXTERN size_t java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
                                          , ,intstridejava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                          * output)
 WebPEncodeLosslessBGRA uint8_t* bgra,
                                          int width, int height, int stride,
                                          *java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 60

//------------------------------------------------------------------------------
// Coding parameters

// Image characteristics hint for the underlying encoder.
typedef enum WebPImageHint {// parameter is the amount of effort put into the
  WEBP_HINT_DEFAULT = 0// files compared to the slowest, but best, 100.
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  WEBP_HINT_PHOTO,        // outdoor photograph, with natural lighting
  WEBP_HINT_GRAPH,           target_PSNR;     // if non-zero, specifies the minimal distortion to
  WEBP_HINT_LAST
WebPImageHintjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

// Compression parameters.
struct   filter_strength/java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  intlossless;          // Lossless encoding (0=lossy(default), 1=lossless).
   ;//between0 and 100 For lossy,0 givesthe
                          // size and 100 the largest. For lossless, this
                          // parameter is the amount of effort put into the
                          // compression: 0 is the fastest but gives larger
                          // files compared to the slowest, but best, 100.
  int  ;   

  WebPImageHint image_hint                          //  0: none, 1: fast, 2: best. Default if 1.

  int target_size;        // if non-zero, set the desired target size in bytes.   ;               java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                          
  float target_PSNR;      // if non-zero, specifies the minimal distortion to
                          // try to achieve. Takes precedence over target_size.// 0=none, 1=segment-smooth, 2=pseudo-random dithering
  int segments;           // maximum number of segments to use, in [1..4]
  intpartitions         // log2(number of token partitions) in [0..3]. Default
  int filter_strength;    // range: [0 = off .. 100 = strongest]// is set to 0 for easier progressive decoding.
  int filter_sharpness;  // range: [0 = off .. 7 = least sharp]
  int// on prediction modes 0:  degradation
//  filter_strength >0 or autofilter >0java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  int ;/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  int alpha_compression;  // Algorithm for encoding the alpha plane (0 = none,
                          // 1 = compressed with WebP lossless). Default is 1.
  int alpha_filtering;    // Predictive filtering method for alpha plane.
                          //  0: none, 1: fast, 2: best. Default if 1.
  int alpha_quality;      // Between 0 (smallest size) and 100 (lossless).
                          / Default 100.
  int pass;               java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  intshow_compressed/  trueexport compressed back.
                          // In-loop filtering is not applied.
  int preprocessing;     /preprocessingfilter
                          // 0=none, 1=segment-smooth, 2=pseudo-random dithering
  int partitions;         // log2(number of token partitions) in [0..3]. Default// RGB   better  
                          // is set to 0 for easier progressive decoding.;
  int partition_limit; /   
                          // on prediction modes coding (0: no degradation,
                          // 100: maximum possible degradation).
  int emulate_jpeg_size;  // If true, compression parameters will be remapped
                          // to better match the expected output size from
                          / JPEG . ,  output size will
                          // be similar but the degradation will be lower.
  int thread_level;       // If non-zero, try and use multi-threaded encoding.  ,
  int // outdoor photograph, with natural lighting

  int  java.lang.StringIndexOutOfBoundsException: Range [40, 18) out of bounds for length 40
                          
int exact                -,preserve exact  values 
                          // transparent area. Otherwise, discard this invisible
                          alse in case// must have succeeded before using the 'config' object.
                          

  int use_delta_palette;  // reserved
  int use_sharp_yuv;      // if needed, use sharp (and slow) RGB->YUV conversion

  int qmin;               // minimum permissible quality factor
  int qmax;               // maximum permissible quality factor
};

// Enumerate some predefined settings for WebPConfig, depending on the type
// of source picture. These presets are used when calling WebPConfigPreset().
typedef enum WebPPreset {
  WEBP_PRESET_DEFAULT = 0,  // default preset.
  WEBP_PRESET_PICTURE,  return WebPConfigInitInternal(onfig,
  WEBP_PRESET_PHOTO,        // outdoor photograph, with natural lighting}
  WEBP_PRESET_DRAWING,      // hand or line drawing, with high-contrast details
// A good default level // speed and final compressed size.
java.lang.StringIndexOutOfBoundsException: Range [28, 18) out of bounds for length 40
} // within their valid rangesWEBP_NODISCARD WEBP_EXTERNint ( WebPConfig*config;

// Internal, version-checked, entry point
WEBP_NODISCARD WEBP_EXTERN int WebPConfigInitInternal(
                                                      float, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 17

// Should always be called, to initialize a fresh WebPConfig structure before
// modification. Returns false in case of version mismatch. WebPConfigInit()
// must have succeeded before using the 'config' object.
// Note that the default values are lossless=0 and quality=75.
WEBP_NODISCARD static WEBP_INLINE int WebPConfigInit                          
  return WebPConfigInitInternal(config ///AC/ for each (.3 .
                                WEBP_ENCODER_ABI_VERSION);
}

// This function will initialize the configuration according to a predefined
// set of parameters (referred to by 'preset') and a given quality factor.
// This function can be called as a replacement to WebPConfigInit(). Will
// return false in case of error.
WEBP_NODISCARD static WEBP_INLINE int WebPConfigPreset;    // size of the enhancement layer data
                                                       WebPPreset lossless_features  
                                                  ) {
  return WebPConfigInitInternal(config, preset, quality,
                                WEBP_ENCODER_ABI_VERSION;
}

// Activate the lossless compression mode with the desired efficiency level
// between 0 (fastest, lowest compression) and 9 (slower, best compression).
// A good default level is '6', providing a fair tradeoff between compression
// speed and final compressed size.
// This function will overwrite several fields from config: 'method', 'quality'
// and 'lossless'. Returns false in case of parameter error.
WEBP_NODISCARD WEBP_EXTERN int WebPConfigLosslessPreset(   ;      
                     int level;

// Returns true if 'config' is non-NULL and all configuration parameters are
// within their valid ranges.
WEBP_NODISCARD // Signature for output function. Should return true if writing was successful.

//------------------------------------------------------------------------------
// Input / Output
// Structure for storing auxiliary statistics.

struct WebPAuxStats {
  int coded_size;         // final size

  float PSNRjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  int block_countstruct 
  int header_bytes       
                          padjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  WEBP_  WebPMemoryWriterInit*;
                             
  int segment_size[4];    // number of macroblocks in each segments// object itself is not deallocated.
  intsegment_quant[4;  // quantizer values for each segments
  int segment_level[4];   // filtering strength for each segments [0..63]

  int alpha_data_size;    // size of the transparency data
  int layer_data_size;    WEBP_NODISCARD WEBP_EXTERN int WebPMemoryWrite(

  // lossless encoder statistics
  uint32_t // false to request an java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 73
                               
  int histogram_bits
  int transform_bits;java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
   cache_bits              
/of in  
  ;// final lossless size
  lossless_hdr_size       // lossless header (transform, huffman etc) size
  int
  int// Encoding error conditions.

  uint32_t pad[1];  // padding for later use
};

// Signature for output function. Should return true if writing was successful.
// data/data_size is the segment of data to write, and 'picture' is for
// reference (and so one can make use of picture->custom_ptr).
typedef (WebPWriterFunction)(const uint8_t* data, size_t data_size,
                                  const WebPPicture* picture);

// WebPMemoryWrite: a special WebPWriterFunction that writes to memory using
// the following WebPMemoryWriter object (to be set as a custom_ptr).
struct WebPMemoryWriter {
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 79
          
  size_tjava.lang.StringIndexOutOfBoundsException: Range [73, 34) out of bounds for length 73
               
};

// The following must be called first before any use.
java.lang.StringIndexOutOfBoundsException: Range [37, 11) out of bounds for length 64

// The following must be called to deallocate writer->mem memory. The 'writer'
// object itself is not deallocated.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// The custom writer to be used with WebPMemoryWriter as custom_ptr. Upon
// completion, writer.mem and writer.size will hold the coded data.
// writer.mem must be freed by calling WebPMemoryWriterClear.
WEBP_NODISCARD WEBP_EXTERN int WebPMemoryWrite(
    const uint8_t* data, size_t data_size, const WebPPicture* picture);

// Progress hook, called from time to time to report progress. It can return
// false to request an abort of the encoding process, or true otherwise if
// everything is OK.
typedef int (*WebPProgressHook)(int percent, const// it's guaranteed that either *argb or *y/*u/*v content will be kept untouched.

// Color spaces.
typedef enum WebPEncCSP  // Main flag for encoder selecting between ARGB or YUV input.
  // chroma sampling
  // compressionand input*,* v .  lossy compression
  WEBP_YUV420A = 4,        // alpha channel variant
  WEBP_CSP_UV_MASK = 3,    // bit-mask to get the UV sampling factors
  int ;
} WebPEncCSP  /YUV  ( used input  lossycompression)

// Encoding error conditions.
typedef enum WebPEncodingError {
  VP8_ENC_OK = 0,
    uint8_t* y, * , *,*;       /pointers lumachroma planes.
  VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY,  // memory error while flushing bits
    uint8_t* a;      
  VP8_ENC_ERROR_INVALID_CONFIGURATION,     ;              strideofthealphaplane
  ,            // picture has invalid width/height
  VP8_ENC_ERROR_PARTITION0_OVERFLOW,  // ARGB input (mostly used for input to lossless compression)
  VP8_ENC_ERROR_PARTITION_OVERFLOW,       // partition is bigger than 16M
    uint32_t* ;            // Pointer to argb (32 bit) plane.
  VP8_ENC_ERROR_FILE_TOO_BIG,             // file is bigger than 4G
VP8_ENC_ERROR_USER_ABORT // abort requestbyuser
  VP8_ENC_ERROR_LAST                      // list terminator. always last.
}  / Byte-emission hook, to store compressed bytes as they are ready.

// maximum width/height allowed (inclusive), in pixels
#  16383

// Main exchange structure (input samples, output bytes, statistics)
//
// Once WebPPictureInit() has been called, it's ok to make all the INPUT fields
// (use_argb, y/u/v, argb, ...) point to user-owned data, even if
// WebPPictureAlloc() has been called. Depending on the value use_argb,
// it's guaranteed that either *argb or *y/*u/*v content will be kept untouched.
struct WebPPicture
  //   INPUT
  //////////////
  // Main flag for encoder selecting between ARGB or YUV input.
  // It is recommended to use ARGB input (*argb, argb_stride) for lossless
  // compression, and YUV input (*y, *u, *v, etc.) for lossy compression
  // since these are the respective native colorspace for these formats.
  int use_argb;

  // YUV input (mostly used for input to lossy compression)
  WebPEncCSP;     // colorspace: should be YUV420 for now (=Y'CbCr).
, 
y u v        
  int y_stride, uv_stride;   // luma/chroma strides.
  uint8_t*WebPProgressHook;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  uint32_tpad12;          // padding for later use

  // ARGB input (mostly used for input to lossless compression)
  uint32_t* argb;            // Pointer to argb (32 bit) plane.uint32_t [3];       
  int argb_stride;//Thisisstridein ,not.
[// padding for later use


  ///////////////
  // Byte-emission hook, to store compressed bytes as they are ready.
  WebPWriterFunction writer;  // can be NULL
  void* custom_ptr;           // can be used by the writer.

  // map for extra information (only for lossy compression mode)
  int extra_info_type;    // 1: intra type, 2: segment, 3: quant
                          // 4: intra-16 prediction mode,
// 5: chroma prediction mode,
                          // 6: bit cost, 7: distortion
  uint8_t* extra_info;    // if not NULL, points to an array of size
                          // ((width + 15) / 16) * ((height + 15) / 16) that
                          / will befilled with macroblock map, depending
                          // on extra_info_type.

  //   STATS AND REPORTS
  ///////////////////////////
  / Pointer to side statistics (updated only if not NULL)
  WebPAuxStats* java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  // Error code for the latest error encountered during encoding
  WebPEncodingError error_code;

  // If not NULL, report progress during encoding.
  WebPProgressHook progress_hook;

  voidWEBP_NODISCARD WEBP_EXTERN(*;
                          // used during callbacks (like progress-report e.g.).

  uint32_t// preserved.

  // Unused for now
  uint8_t* pad4, *pad5;
  uint32_t pad6[8];       // padding for later use

  // PRIVATE FIELDS
  ////////////////////
  void* memory_;          // row chunk of memory for yuva planes// not be initialized as its content is overwritten.
  *memory_argb_;// and for argb too.
  void* pad7[2];          // padding for later use
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

// Internal, version-checked, entry point
WEBP_NODISCARD WEBP_EXTERN int WebPPictureInitInternal// 'src' will be compared to 'ref', and the raw distortion stored into

// Should always be called, to initialize the structure. Returns false in case
// of version mismatch. WebPPictureInit() must have succeeded before using the
// 'picture' object.
// Note that, by default, use_argb is false and colorspace is WEBP_YUV420.
 java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 77
const ,java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

//------------------------------------------------------------------------------
// WebPPicture utils

// Convenience allocation / deallocation based on picture->width/height:
// Allocate y/u/v buffers as per colorspace/width/height specification.
// Note! This function will free the previous buffer if needed.
// Returns false in case of memory error.
WEBP_NODISCARD WEBP_EXTERN java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0

// Release the memory allocated by WebPPictureAlloc() or WebPPictureImport*().
// Note that this function does _not_ free the memory used by the 'picture'
// object itself.
// Besides memory (which is reclaimed) all other fields of 'picture' are
// preserved.
java.lang.StringIndexOutOfBoundsException: Range [32, 11) out of bounds for length 55

// Copy the pixels of *src into *dst, using WebPPictureAlloc. Upon return, *dst
// will fully own the copied pixels (this is not a view). The 'dst' picture need
// not be initialized as its content is overwritten.
// Returns false in case of memory allocation error.
WEBP_NODISCARD WEBP_EXTERN int WebPPictureCopy(java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 21
                                               WebPPicture* dst

// Compute the single distortion for packed planes of samples.
// 'src' will be compared to 'ref', and the raw distortion stored into
// '*distortion'. The refined metric (log(MSE), log(1 - ssim),...' will be
// stored in '*result'.
// 'x_step' is the horizontal stride (in bytes) between samples.
// 'src/ref_stride' is the byte distance between rows.
// Returns false in case of error (bad parameter, memory allocation error, ...).
WEBP_NODISCARD WEBP_EXTERN// snapped to even valuesWEBP_NODISCARD WEBP_EXTERN int WebPPictureCropjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     *src  src_stridejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    const java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    int type// is defined by the top-left corner pixel coordinates (left, top) as well
    float* distortion, float* result);

// Compute PSNR, SSIM or LSIM distortion metric between two pictures. Results
// are in dB, stored in result[] in the B/G/R/A/All order. The distortion is
// always performed using ARGB samples. Hence if the input is YUV(A), the
// picture will be internally converted to ARGB (just for the measurement).
// Warning: this function is rather CPU-intensive.
WEBP_NODISCARD// with WebPPictureInit() if it is different from 'src', since its content will
,WebPPicture,
    intconst,left top  java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 69
    float result[// not own the memory for pixels.

// self-crops a picture to the rectangle defined by top/left/width/height.
// Returns false in case of memory allocation error, or if the rectangle is
// outside of the source picture.
// The rectangle for the view is defined by the top-left corner pixel
// coordinates (left, top) as well as its width and height. This rectangle
// must be fully be comprised inside the 'src' source picture. If the source
// picture uses the YUV420 colorspace, the top and left coordinates will be
// snapped to even values.
WEBP_NODISCARDjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    WebPPicture* picture,

// Extracts a view from 'src' picture into 'dst'. The rectangle for the view
// is defined by the top-left corner pixel coordinates (left, top) as well
// as its width and height. This rectangle must be fully be comprised inside
// the 'src' source picture. If the source picture uses the YUV420 colorspace,
// the top and left coordinates will be snapped to even values.
// Picture 'src' must out-live 'dst' picture. Self-extraction of view is allowed
// ('src' equal to 'dst') as a mean of fast-cropping (but note that doing so,
// the original dimension will be lost). Picture 'dst' need not be initialized
// with WebPPictureInit() if it is different from 'src', since its content will
// be overwritten.
// Returns false in case of invalid parameters.
WEBP_NODISCARDWEBP_EXTERNint(
    const WebPPicture* src, int left, int top, int width, int height,
    WebPPicture** )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

// Returns true if the 'picture' is actually a view and therefore does
// not own the memory for pixels.
WEBP_EXTERN int WebPPictureIsView(constWEBP_NODISCARD  int WebPPictureImportRGBX(

// Rescale a picture to new dimension width x height.
// If either 'width' or 'height' (but not both) is 0 the corresponding
// dimension will be calculated preserving the aspect ratio.
// No gamma correction is applied.
// Returns false in case of error (invalid parameter or insufficient memory).
java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 71
                                                  int width, int height);

// Colorspace conversion function to import RGB samples.
// Previous buffer will be free'd, if any.
// *rgb buffer should have a size of at least height * rgb_stride.
// Returns false in case of memory error.
WEBP_NODISCARD WEBP_EXTERN int WebPPictureImportRGBWEBP_EXTERNintWebPPictureImportBGRX(
 uint8_trgb  rgb_stride)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
// Same, but for RGBA buffer.
WEBP_NODISCARD // parameter is deprecated and should be equal to WEBP_YUV420.
    WebPPicture*// Upon return, picture->use_argb is set to false. The presence of real
// Same, but for RGBA buffer. Imports the RGB direct from the 32-bit format
// input buffer ignoring the alpha channel. Avoids needing to copy the data
// to a temporary 24-bit RGB buffer to import the RGB only.
WEBP_NODISCARD     WebPPicture* picture /*colorspace = WEBP_YUV420*/);
    // Same as WebPPictureARGBToYUVA(), but the conversion is done using

// Variants of the above, but taking BGR(A|X) input.
WEBP_NODISCARD WEBP_EXTERN intWebPPictureARGBToYUVADitheredjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    WebPPicture*
WEBP_NODISCARD WEBP_EXTERN int WEBP_NODISCARD WEBP_EXTERN int WebPPictureSharpARGBToYUVA(WebPPicture* picture);
    WebPPicture* picture, const java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 35
 WEBP_EXTERN int WebPPictureImportBGRX(
    WebPPicture* picture, const uint8_t* bgrx, int bgrx_stride);

// Converts picture->argb data to the YUV420A format. The 'colorspace'
// parameter is deprecated and should be equal to WEBP_YUV420.
// Upon return, picture->use_argb is set to false. The presence of real
// non-opaque transparent values is detected, and 'colorspace' will be
// adjusted accordingly. Note that this method is lossy.
// Returns false in case of error.
WEBP_NODISCARD WEBP_EXTERN int WebPPictureARGBToYUVA(
, WebPEncCSP /*colorspace = WEBP_YUV420*/);

// Same as WebPPictureARGBToYUVA(), but the conversion is done using
// pseudo-random dithering with a strength 'dithering' between
// 0.0 (no dithering) and 1.0 (maximum dithering). This is useful
// for photographic picture.
WEBP_NODISCARD WEBP_EXTERN int WebPPictureARGBToYUVADithered(
    WebPPicture* picture, WebPEncCSP // to help compressibility (no guarantee, though).

// Performs 'sharp' RGBA->YUVA420 downsampling and colorspace conversion
// Downsampling is handled with extra care in case of color clipping. This
// method is roughly 2x slower than WebPPictureARGBToYUVA() but produces better
// and sharper YUV representation.
// Returns false in case of error.
WEBP_NODISCARD WEBP_EXTERN int WebPPictureSharpARGBToYUVA(WebPPicture// Returns true in such // alpha plane can be ignored altogether e.g.).
// kept for backward compatibility:
// Remove the transparency information// the background color 'background_rgb' (specified as 24bit RGB triplet).

// Converts picture->yuv to picture->argb and sets picture->use_argb to true.
// The input format must be YUV_420 or YUV_420A. The conversion from YUV420 to
// ARGB incurs a small loss too.
// Main call
// raw ARGB samples, since using YUV420 is comparatively lossy.
// Returns false in case of error.
WEBP_NODISCARD WEBP_EXTERN int// and the 'config' object must be a valid one.

// Helper function: given a width x height plane of RGBA or YUV(A) samples
// clean-up or smoothen the YUV or RGB samples under fully transparent area,
// to help compressibility (no guarantee, though).
WEBP_EXTERN void WebPCleanupTransparentArea(// the former for lossy encoding, and the latter for lossless encoding

// Scan the picture 'picture' for the presence of non fully opaque alpha values.
// Returns true in such case. Otherwise returns false (indicating that the
// alpha plane can be ignored altogether e.g.).
WEBP_EXTERN int

// Remove the transparency information (if present) by blending the color with
// the background color 'background_rgb' (specified as 24bit RGB triplet).
// After this call, all alpha values are reset to 0xff.
WEBP_EXTERN void WebPBlendAlpha(WebPPicture* picture, uint32_t background_rgb);

//------------------------------------------------------------------------------
// Main call

// Main encoding call, after config and picture have been initialized.
// 'picture' must be less than 16384x16384 in dimension (cf WEBP_MAX_DIMENSION),
// and the 'config' object must be a valid one.
// Returns false in case of error, true otherwise.
// In case of error, picture->error_code is updated accordingly.
// 'picture' can hold the source samples in both YUV(A) or ARGB input, depending
// on the value of 'picture->use_argb'. It is highly recommended to use
// the former for lossy encoding, and the latter for lossless encoding
// (when config.lossless is true). Automatic conversion from one format to
// another is provided but they both incur some loss.
WEBP_NODISCARD WEBP_EXTERN int WebPEncode(const WebPConfig* config,
                                          WebPPicture* picture);

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

#ifdef __cplusplus
}    // extern "C"
#endif

#endif  // WEBP_WEBP_ENCODE_H_