/src/libjpeg-turbo.dev/src/jstdhuff.c

Source
/*
 * jstdhuff.c
 *
 * This file was part of the Independent JPEG Group's software:
 * Copyright (C) 1991-1998, Thomas G. Lane.
 * libjpeg-turbo Modifications:
 * Copyright (C) 2013, 2022, 2024, D. R. Commander.
 * For conditions of distribution and use, see the accompanying README.ijg
 * file.
 *
 * This file contains routines to set the default Huffman tables, if they are
 * not already set.
 */

/*
 * Huffman table setup routines
 */

LOCAL(void)
add_huff_table(j_common_ptr cinfo, JHUFF_TBL **htblptr, const UINT8 *bits,
               const UINT8 *val)
/* Define a Huffman table */
{
  int nsymbols, len;

  if (*htblptr == NULL)
    *htblptr = jpeg_alloc_huff_table(cinfo);
  else if (cinfo->is_decompressor)
    return;

  /* Copy the number-of-symbols-of-each-code-length counts */
  memcpy((*htblptr)->bits, bits, sizeof((*htblptr)->bits));

  /* Validate the counts.  We do this here mainly so we can copy the right
   * number of symbols from the val[] array, without risking marching off
   * the end of memory.  jchuff.c will do a more thorough test later.
   */
  nsymbols = 0;
  for (len = 1; len <= 16; len++)
    nsymbols += bits[len];
  if (nsymbols < 1 || nsymbols > 256)
    ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);

  memcpy((*htblptr)->huffval, val, nsymbols * sizeof(UINT8));
  memset(&((*htblptr)->huffval[nsymbols]), 0,
         (256 - nsymbols) * sizeof(UINT8));

  /* Initialize sent_table FALSE so table will be written to JPEG file. */
  (*htblptr)->sent_table = FALSE;
}


LOCAL(void)
std_huff_tables(j_common_ptr cinfo)
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
/* IMPORTANT: these are only valid for 8-bit data precision! */
{
  JHUFF_TBL **dc_huff_tbl_ptrs, **ac_huff_tbl_ptrs;

  static const UINT8 bits_dc_luminance[17] = {
    /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
  };
  static const UINT8 val_dc_luminance[] = {
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
  };

  static const UINT8 bits_dc_chrominance[17] = {
    /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
  };
  static const UINT8 val_dc_chrominance[] = {
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
  };

  static const UINT8 bits_ac_luminance[17] = {
    /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
  };
  static const UINT8 val_ac_luminance[] = {
    0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
    0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
    0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
    0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
    0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
    0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
    0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
    0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
    0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
    0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
    0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
    0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
    0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
    0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
    0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
    0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
    0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
    0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
    0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
    0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
    0xf9, 0xfa
  };

  static const UINT8 bits_ac_chrominance[17] = {
    /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
  };
  static const UINT8 val_ac_chrominance[] = {
    0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
    0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
    0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
    0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
    0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
    0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
    0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
    0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
    0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
    0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
    0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
    0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
    0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
    0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
    0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
    0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
    0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
    0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
    0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
    0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
    0xf9, 0xfa
  };

  if (cinfo->is_decompressor) {
    dc_huff_tbl_ptrs = ((j_decompress_ptr)cinfo)->dc_huff_tbl_ptrs;
    ac_huff_tbl_ptrs = ((j_decompress_ptr)cinfo)->ac_huff_tbl_ptrs;
  } else {
    dc_huff_tbl_ptrs = ((j_compress_ptr)cinfo)->dc_huff_tbl_ptrs;
    ac_huff_tbl_ptrs = ((j_compress_ptr)cinfo)->ac_huff_tbl_ptrs;
  }

  add_huff_table(cinfo, &dc_huff_tbl_ptrs[0], bits_dc_luminance,
                 val_dc_luminance);
  add_huff_table(cinfo, &ac_huff_tbl_ptrs[0], bits_ac_luminance,
                 val_ac_luminance);
  add_huff_table(cinfo, &dc_huff_tbl_ptrs[1], bits_dc_chrominance,
                 val_dc_chrominance);
  add_huff_table(cinfo, &ac_huff_tbl_ptrs[1], bits_ac_chrominance,
                 val_ac_chrominance);
}

Coverage Report

Created: 2025-10-10 07:04

Line	Count	Source
1		/*
2		* jstdhuff.c
3		*
4		* This file was part of the Independent JPEG Group's software:
5		* Copyright (C) 1991-1998, Thomas G. Lane.
6		* libjpeg-turbo Modifications:
7		* Copyright (C) 2013, 2022, 2024, D. R. Commander.
8		* For conditions of distribution and use, see the accompanying README.ijg
9		* file.
10		*
11		* This file contains routines to set the default Huffman tables, if they are
12		* not already set.
13		*/
14
15		/*
16		* Huffman table setup routines
17		*/
18
19		LOCAL(void)
20		add_huff_table(j_common_ptr cinfo, JHUFF_TBL *htblptr, const UINT8 bits,
21		const UINT8 *val)
22		/* Define a Huffman table */
23	464	{
24	464	int nsymbols, len;
25
26	464	if (*htblptr == NULL)
27	464	*htblptr = jpeg_alloc_huff_table(cinfo);
28	0	else if (cinfo->is_decompressor)
29	0	return;
30
31		/* Copy the number-of-symbols-of-each-code-length counts */
32	464	memcpy((htblptr)->bits, bits, sizeof((htblptr)->bits));
33
34		/* Validate the counts. We do this here mainly so we can copy the right
35		* number of symbols from the val[] array, without risking marching off
36		* the end of memory. jchuff.c will do a more thorough test later.
37		*/
38	464	nsymbols = 0;
39	7.88k	for (len = 1; len <= 16; len++)
40	7.42k	nsymbols += bits[len];
41	464	if (nsymbols < 1 \|\| nsymbols > 256)
42	0	ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
43
44	464	memcpy((htblptr)->huffval, val, nsymbols sizeof(UINT8));
45	464	memset(&((*htblptr)->huffval[nsymbols]), 0,
46	464	(256 - nsymbols) * sizeof(UINT8));
47
48		/* Initialize sent_table FALSE so table will be written to JPEG file. */
49	464	(*htblptr)->sent_table = FALSE;
50	464	}
51
52
53		LOCAL(void)
54		std_huff_tables(j_common_ptr cinfo)
55		/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
56		/* IMPORTANT: these are only valid for 8-bit data precision! */
57	116	{
58	116	JHUFF_TBL dc_huff_tbl_ptrs, ac_huff_tbl_ptrs;
59
60	116	static const UINT8 bits_dc_luminance[17] = {
61	116	/* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
62	116	};
63	116	static const UINT8 val_dc_luminance[] = {
64	116	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
65	116	};
66
67	116	static const UINT8 bits_dc_chrominance[17] = {
68	116	/* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
69	116	};
70	116	static const UINT8 val_dc_chrominance[] = {
71	116	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
72	116	};
73
74	116	static const UINT8 bits_ac_luminance[17] = {
75	116	/* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
76	116	};
77	116	static const UINT8 val_ac_luminance[] = {
78	116	0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
79	116	0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
80	116	0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
81	116	0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
82	116	0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
83	116	0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
84	116	0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
85	116	0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
86	116	0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
87	116	0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
88	116	0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
89	116	0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
90	116	0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
91	116	0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
92	116	0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
93	116	0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
94	116	0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
95	116	0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
96	116	0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
97	116	0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
98	116	0xf9, 0xfa
99	116	};
100
101	116	static const UINT8 bits_ac_chrominance[17] = {
102	116	/* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
103	116	};
104	116	static const UINT8 val_ac_chrominance[] = {
105	116	0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
106	116	0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
107	116	0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
108	116	0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
109	116	0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
110	116	0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
111	116	0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
112	116	0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
113	116	0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
114	116	0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
115	116	0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
116	116	0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
117	116	0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
118	116	0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
119	116	0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
120	116	0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
121	116	0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
122	116	0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
123	116	0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
124	116	0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
125	116	0xf9, 0xfa
126	116	};
127
128	116	if (cinfo->is_decompressor) {
129	0	dc_huff_tbl_ptrs = ((j_decompress_ptr)cinfo)->dc_huff_tbl_ptrs;
130	0	ac_huff_tbl_ptrs = ((j_decompress_ptr)cinfo)->ac_huff_tbl_ptrs;
131	116	} else {
132	116	dc_huff_tbl_ptrs = ((j_compress_ptr)cinfo)->dc_huff_tbl_ptrs;
133	116	ac_huff_tbl_ptrs = ((j_compress_ptr)cinfo)->ac_huff_tbl_ptrs;
134	116	}
135
136	116	add_huff_table(cinfo, &dc_huff_tbl_ptrs[0], bits_dc_luminance,
137	116	val_dc_luminance);
138	116	add_huff_table(cinfo, &ac_huff_tbl_ptrs[0], bits_ac_luminance,
139	116	val_ac_luminance);
140	116	add_huff_table(cinfo, &dc_huff_tbl_ptrs[1], bits_dc_chrominance,
141	116	val_dc_chrominance);
142	116	add_huff_table(cinfo, &ac_huff_tbl_ptrs[1], bits_ac_chrominance,
143	116	val_ac_chrominance);
144	116	}