tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

jutils.c (4129B)

      1 /*
      2 * jutils.c
      3 *
      4 * This file was part of the Independent JPEG Group's software:
      5 * Copyright (C) 1991-1996, Thomas G. Lane.
      6 * libjpeg-turbo Modifications:
      7 * Copyright (C) 2022, D. R. Commander.
      8 * For conditions of distribution and use, see the accompanying README.ijg
      9 * file.
     10 *
     11 * This file contains tables and miscellaneous utility routines needed
     12 * for both compression and decompression.
     13 * Note we prefix all global names with "j" to minimize conflicts with
     14 * a surrounding application.
     15 */
     16 
     17 #define JPEG_INTERNALS
     18 #include "jinclude.h"
     19 #include "jpeglib.h"
     20 #include "jsamplecomp.h"
     21 
     22 
     23 #if BITS_IN_JSAMPLE == 8
     24 
     25 /*
     26 * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
     27 * of a DCT block read in natural order (left to right, top to bottom).
     28 */
     29 
     30 #if 0                           /* This table is not actually needed in v6a */
     31 
     32 const int jpeg_zigzag_order[DCTSIZE2] = {
     33   0,  1,  5,  6, 14, 15, 27, 28,
     34   2,  4,  7, 13, 16, 26, 29, 42,
     35   3,  8, 12, 17, 25, 30, 41, 43,
     36   9, 11, 18, 24, 31, 40, 44, 53,
     37  10, 19, 23, 32, 39, 45, 52, 54,
     38  20, 22, 33, 38, 46, 51, 55, 60,
     39  21, 34, 37, 47, 50, 56, 59, 61,
     40  35, 36, 48, 49, 57, 58, 62, 63
     41 };
     42 
     43 #endif
     44 
     45 /*
     46 * jpeg_natural_order[i] is the natural-order position of the i'th element
     47 * of zigzag order.
     48 *
     49 * When reading corrupted data, the Huffman decoders could attempt
     50 * to reference an entry beyond the end of this array (if the decoded
     51 * zero run length reaches past the end of the block).  To prevent
     52 * wild stores without adding an inner-loop test, we put some extra
     53 * "63"s after the real entries.  This will cause the extra coefficient
     54 * to be stored in location 63 of the block, not somewhere random.
     55 * The worst case would be a run-length of 15, which means we need 16
     56 * fake entries.
     57 */
     58 
     59 const int jpeg_natural_order[DCTSIZE2 + 16] = {
     60  0,  1,  8, 16,  9,  2,  3, 10,
     61 17, 24, 32, 25, 18, 11,  4,  5,
     62 12, 19, 26, 33, 40, 48, 41, 34,
     63 27, 20, 13,  6,  7, 14, 21, 28,
     64 35, 42, 49, 56, 57, 50, 43, 36,
     65 29, 22, 15, 23, 30, 37, 44, 51,
     66 58, 59, 52, 45, 38, 31, 39, 46,
     67 53, 60, 61, 54, 47, 55, 62, 63,
     68 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
     69 63, 63, 63, 63, 63, 63, 63, 63
     70 };
     71 
     72 
     73 /*
     74 * Arithmetic utilities
     75 */
     76 
     77 GLOBAL(long)
     78 jdiv_round_up(long a, long b)
     79 /* Compute a/b rounded up to next integer, ie, ceil(a/b) */
     80 /* Assumes a >= 0, b > 0 */
     81 {
     82  return (a + b - 1L) / b;
     83 }
     84 
     85 
     86 GLOBAL(long)
     87 jround_up(long a, long b)
     88 /* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
     89 /* Assumes a >= 0, b > 0 */
     90 {
     91  a += b - 1L;
     92  return a - (a % b);
     93 }
     94 
     95 #endif /* BITS_IN_JSAMPLE == 8 */
     96 
     97 
     98 #if BITS_IN_JSAMPLE != 16 || \
     99    defined(C_LOSSLESS_SUPPORTED) || defined(D_LOSSLESS_SUPPORTED)
    100 
    101 GLOBAL(void)
    102 _jcopy_sample_rows(_JSAMPARRAY input_array, int source_row,
    103                   _JSAMPARRAY output_array, int dest_row, int num_rows,
    104                   JDIMENSION num_cols)
    105 /* Copy some rows of samples from one place to another.
    106 * num_rows rows are copied from input_array[source_row++]
    107 * to output_array[dest_row++]; these areas may overlap for duplication.
    108 * The source and destination arrays must be at least as wide as num_cols.
    109 */
    110 {
    111  register _JSAMPROW inptr, outptr;
    112  register size_t count = (size_t)(num_cols * sizeof(_JSAMPLE));
    113  register int row;
    114 
    115  input_array += source_row;
    116  output_array += dest_row;
    117 
    118  for (row = num_rows; row > 0; row--) {
    119    inptr = *input_array++;
    120    outptr = *output_array++;
    121    memcpy(outptr, inptr, count);
    122  }
    123 }
    124 
    125 #endif /* BITS_IN_JSAMPLE != 16 ||
    126          defined(C_LOSSLESS_SUPPORTED) || defined(D_LOSSLESS_SUPPORTED) */
    127 
    128 
    129 #if BITS_IN_JSAMPLE == 8
    130 
    131 GLOBAL(void)
    132 jcopy_block_row(JBLOCKROW input_row, JBLOCKROW output_row,
    133                JDIMENSION num_blocks)
    134 /* Copy a row of coefficient blocks from one place to another. */
    135 {
    136  memcpy(output_row, input_row, num_blocks * (DCTSIZE2 * sizeof(JCOEF)));
    137 }
    138 
    139 
    140 GLOBAL(void)
    141 jzero_far(void *target, size_t bytestozero)
    142 /* Zero out a chunk of memory. */
    143 /* This might be sample-array data, block-array data, or alloc_large data. */
    144 {
    145  memset(target, 0, bytestozero);
    146 }
    147 
    148 #endif /* BITS_IN_JSAMPLE == 8 */