/src/libjpeg-turbo/jutils.c

Source (jump to first uncovered line)
/*
 * jutils.c
 *
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-1996, Thomas G. Lane.
 * libjpeg-turbo Modifications:
 * Copyright (C) 2022, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
 * This file contains tables and miscellaneous utility routines needed
 * for both compression and decompression.
 * Note we prefix all global names with "j" to minimize conflicts with
 * a surrounding application.
 */

#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"
#include "jsamplecomp.h"


#if BITS_IN_JSAMPLE == 8

/*
 * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
 * of a DCT block read in natural order (left to right, top to bottom).
 */

#if 0                           /* This table is not actually needed in v6a */

const int jpeg_zigzag_order[DCTSIZE2] = {
   0,  1,  5,  6, 14, 15, 27, 28,
   2,  4,  7, 13, 16, 26, 29, 42,
   3,  8, 12, 17, 25, 30, 41, 43,
   9, 11, 18, 24, 31, 40, 44, 53,
  10, 19, 23, 32, 39, 45, 52, 54,
  20, 22, 33, 38, 46, 51, 55, 60,
  21, 34, 37, 47, 50, 56, 59, 61,
  35, 36, 48, 49, 57, 58, 62, 63
};

#endif

/*
 * jpeg_natural_order[i] is the natural-order position of the i'th element
 * of zigzag order.
 *
 * When reading corrupted data, the Huffman decoders could attempt
 * to reference an entry beyond the end of this array (if the decoded
 * zero run length reaches past the end of the block).  To prevent
 * wild stores without adding an inner-loop test, we put some extra
 * "63"s after the real entries.  This will cause the extra coefficient
 * to be stored in location 63 of the block, not somewhere random.
 * The worst case would be a run-length of 15, which means we need 16
 * fake entries.
 */

const int jpeg_natural_order[DCTSIZE2 + 16] = {
  0,  1,  8, 16,  9,  2,  3, 10,
 17, 24, 32, 25, 18, 11,  4,  5,
 12, 19, 26, 33, 40, 48, 41, 34,
 27, 20, 13,  6,  7, 14, 21, 28,
 35, 42, 49, 56, 57, 50, 43, 36,
 29, 22, 15, 23, 30, 37, 44, 51,
 58, 59, 52, 45, 38, 31, 39, 46,
 53, 60, 61, 54, 47, 55, 62, 63,
 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
 63, 63, 63, 63, 63, 63, 63, 63
};


/*
 * Arithmetic utilities
 */

GLOBAL(long)
jdiv_round_up(long a, long b)
/* Compute a/b rounded up to next integer, ie, ceil(a/b) */
/* Assumes a >= 0, b > 0 */
{
  return (a + b - 1L) / b;
}


GLOBAL(long)
jround_up(long a, long b)
/* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
/* Assumes a >= 0, b > 0 */
{
  a += b - 1L;
  return a - (a % b);
}

#endif /* BITS_IN_JSAMPLE == 8 */


#if BITS_IN_JSAMPLE != 16 || \
    defined(C_LOSSLESS_SUPPORTED) || defined(D_LOSSLESS_SUPPORTED)

GLOBAL(void)
_jcopy_sample_rows(_JSAMPARRAY input_array, int source_row,
                   _JSAMPARRAY output_array, int dest_row, int num_rows,
                   JDIMENSION num_cols)
/* Copy some rows of samples from one place to another.
 * num_rows rows are copied from input_array[source_row++]
 * to output_array[dest_row++]; these areas may overlap for duplication.
 * The source and destination arrays must be at least as wide as num_cols.
 */
{
  register _JSAMPROW inptr, outptr;
  register size_t count = (size_t)(num_cols * sizeof(_JSAMPLE));
  register int row;

  input_array += source_row;
  output_array += dest_row;

  for (row = num_rows; row > 0; row--) {
    inptr = *input_array++;
    outptr = *output_array++;
    memcpy(outptr, inptr, count);
  }
}

#endif /* BITS_IN_JSAMPLE != 16 ||
          defined(C_LOSSLESS_SUPPORTED) || defined(D_LOSSLESS_SUPPORTED) */


#if BITS_IN_JSAMPLE == 8

GLOBAL(void)
jcopy_block_row(JBLOCKROW input_row, JBLOCKROW output_row,
                JDIMENSION num_blocks)
/* Copy a row of coefficient blocks from one place to another. */
{
  memcpy(output_row, input_row, num_blocks * (DCTSIZE2 * sizeof(JCOEF)));
}


GLOBAL(void)
jzero_far(void *target, size_t bytestozero)
/* Zero out a chunk of memory. */
/* This might be sample-array data, block-array data, or alloc_large data. */
{
  memset(target, 0, bytestozero);
}

#endif /* BITS_IN_JSAMPLE == 8 */

Coverage Report

Created: 2024-06-18 06:05

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		#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	0	{
82	0	return (a + b - 1L) / b;
83	0	}
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	0	{
91	0	a += b - 1L;
92	0	return a - (a % b);
93	0	}
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	0	{
111	0	register _JSAMPROW inptr, outptr;
112	0	register size_t count = (size_t)(num_cols * sizeof(_JSAMPLE));
113	0	register int row;
114
115	0	input_array += source_row;
116	0	output_array += dest_row;
117
118	0	for (row = num_rows; row > 0; row--) {
119	0	inptr = *input_array++;
120	0	outptr = *output_array++;
121	0	memcpy(outptr, inptr, count);
122	0	}
123	0	} Unexecuted instantiation: jcopy_sample_rows Unexecuted instantiation: j12copy_sample_rows Unexecuted instantiation: j16copy_sample_rows
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	0	{
136	0	memcpy(output_row, input_row, num_blocks * (DCTSIZE2 * sizeof(JCOEF)));
137	0	}
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	0	{
145	0	memset(target, 0, bytestozero);
146	0	}
147
148		#endif /* BITS_IN_JSAMPLE == 8 */