Create an error message in allocated memory and set state->err and state->msg accordingly. Free any previous error message already there. Do n

========================================================================= * Check for a valid deflate stream state. Return 0 if ok, 1 if not. */

========================================================================= * Flush as much pending output as possible. All deflate() output, except fo

========================================================================= */

Compress whatever is at avail_in and next_in and write to the output file. Return -1 if there is an error writing to the output file or if gz_init(

Build a set of tables to decode the provided canonical Huffman code. The code lengths are lens[0..codes-1]. The result starts at *table, whose

fast 0..255 * 0..255 => 0..255 rounded multiplication

Format help message

========================================================================= */

take a -128..127 value and stbi__clamp it and convert to 0..255

returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow

Compress len zeros to output. Return -1 on a write error or memory allocation failure by gz_comp(), or 0 on success. */

initialize a callback-based context

initialize a memory-decode context

=========================================================================== * Fill the window when the lookahead becomes insufficient. * Updates str

if there's a pending marker from the entropy stream, return that otherwise, fetch from the stream and get a marker. if there's no marker, return 0xff,

returns 1 if the product is valid, 0 on overflow. negative factors are considered invalid.

========================================================================= * Put a short in the pending buffer. The 16-bit value is put in MSB order.

clean up the temporary component buffers

decode a jpeg huffman value from the bitstream

after a restart interval, stbi__jpeg_reset the entropy decoder and the dc prediction

initialize a callback-based context

=========================================================================== * Send a stored block */

========================================================================= */

========================================================================= */

Initialize state for writing a gzip file. Mark initialization by setting state->size to non-zero. Return -1 on a memory allocation failure, or 0

Open a gzip file either by name or file descriptor. */

Write len bytes from buf to file. Return the number of bytes written. If the returned value is less than len, then there was an error. */

combined JPEG 'receive' and JPEG 'extend', since baseline always extends everything it receives.

returns 0..31 for the highest set bit

mallocs with size overflow checking

extract an arbitrarily-aligned N-bit value (N=bits) from v, and then make it 8-bits long and fractionally extend it to full full range.

returns STBI_rgb or whatever, 0 on error

=========================================================================== * Construct one Huffman tree and assigns the code bit strings and lengths

=========================================================================== * Check that the match at match_start is indeed a match. */

========================================================================= */

========================================================================= */

Fetch data and put it in the output buffer. Assumes state->x.have is 0. Data is either copied from the input file or decompressed from the input

Use read() to load a buffer -- return -1 on error, otherwise 0. Read from state->fd, and update state->eof, state->err, and state->msg as appropri

Read len bytes into buf from file, or less than len up to the end of the input. Return the number of bytes read. If zero is returned, either the

Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */

=========================================================================== * Read a new buffer from the current input stream, update the adler32 *

return 1 if the sum is valid, 0 on overflow. negative terms are considered invalid.