Coverage Report

Created: 2024-05-04 12:45

/proc/self/cwd/external/libjpeg_turbo/jutils.c
Line
Count
Source (jump to first uncovered line)
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
21
22
/*
23
 * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
24
 * of a DCT block read in natural order (left to right, top to bottom).
25
 */
26
27
#if 0                           /* This table is not actually needed in v6a */
28
29
const int jpeg_zigzag_order[DCTSIZE2] = {
30
   0,  1,  5,  6, 14, 15, 27, 28,
31
   2,  4,  7, 13, 16, 26, 29, 42,
32
   3,  8, 12, 17, 25, 30, 41, 43,
33
   9, 11, 18, 24, 31, 40, 44, 53,
34
  10, 19, 23, 32, 39, 45, 52, 54,
35
  20, 22, 33, 38, 46, 51, 55, 60,
36
  21, 34, 37, 47, 50, 56, 59, 61,
37
  35, 36, 48, 49, 57, 58, 62, 63
38
};
39
40
#endif
41
42
/*
43
 * jpeg_natural_order[i] is the natural-order position of the i'th element
44
 * of zigzag order.
45
 *
46
 * When reading corrupted data, the Huffman decoders could attempt
47
 * to reference an entry beyond the end of this array (if the decoded
48
 * zero run length reaches past the end of the block).  To prevent
49
 * wild stores without adding an inner-loop test, we put some extra
50
 * "63"s after the real entries.  This will cause the extra coefficient
51
 * to be stored in location 63 of the block, not somewhere random.
52
 * The worst case would be a run-length of 15, which means we need 16
53
 * fake entries.
54
 */
55
56
const int jpeg_natural_order[DCTSIZE2 + 16] = {
57
  0,  1,  8, 16,  9,  2,  3, 10,
58
 17, 24, 32, 25, 18, 11,  4,  5,
59
 12, 19, 26, 33, 40, 48, 41, 34,
60
 27, 20, 13,  6,  7, 14, 21, 28,
61
 35, 42, 49, 56, 57, 50, 43, 36,
62
 29, 22, 15, 23, 30, 37, 44, 51,
63
 58, 59, 52, 45, 38, 31, 39, 46,
64
 53, 60, 61, 54, 47, 55, 62, 63,
65
 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
66
 63, 63, 63, 63, 63, 63, 63, 63
67
};
68
69
70
/*
71
 * Arithmetic utilities
72
 */
73
74
GLOBAL(long)
75
jdiv_round_up(long a, long b)
76
/* Compute a/b rounded up to next integer, ie, ceil(a/b) */
77
/* Assumes a >= 0, b > 0 */
78
12.6k
{
79
12.6k
  return (a + b - 1L) / b;
80
12.6k
}
81
82
83
GLOBAL(long)
84
jround_up(long a, long b)
85
/* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
86
/* Assumes a >= 0, b > 0 */
87
681
{
88
681
  a += b - 1L;
89
681
  return a - (a % b);
90
681
}
91
92
93
GLOBAL(void)
94
jcopy_sample_rows(JSAMPARRAY input_array, int source_row,
95
                  JSAMPARRAY output_array, int dest_row, int num_rows,
96
                  JDIMENSION num_cols)
97
/* Copy some rows of samples from one place to another.
98
 * num_rows rows are copied from input_array[source_row++]
99
 * to output_array[dest_row++]; these areas may overlap for duplication.
100
 * The source and destination arrays must be at least as wide as num_cols.
101
 */
102
1.71M
{
103
1.71M
  register JSAMPROW inptr, outptr;
104
1.71M
  register size_t count = (size_t)(num_cols * sizeof(JSAMPLE));
105
1.71M
  register int row;
106
107
1.71M
  input_array += source_row;
108
1.71M
  output_array += dest_row;
109
110
3.49M
  for (row = num_rows; row > 0; row--) {
111
1.78M
    inptr = *input_array++;
112
1.78M
    outptr = *output_array++;
113
1.78M
    memcpy(outptr, inptr, count);
114
1.78M
  }
115
1.71M
}
116
117
118
GLOBAL(void)
119
jcopy_block_row(JBLOCKROW input_row, JBLOCKROW output_row,
120
                JDIMENSION num_blocks)
121
/* Copy a row of coefficient blocks from one place to another. */
122
0
{
123
0
  memcpy(output_row, input_row, num_blocks * (DCTSIZE2 * sizeof(JCOEF)));
124
0
}
125
126
127
GLOBAL(void)
128
jzero_far(void *target, size_t bytestozero)
129
/* Zero out a chunk of memory. */
130
/* This might be sample-array data, block-array data, or alloc_large data. */
131
2.45M
{
132
2.45M
  memset(target, 0, bytestozero);
133
2.45M
}