/src/ghostpdl/obj/jcomapi.c

Source (jump to first uncovered line)
/*
 * jcomapi.c
 *
 * Copyright (C) 1994-1997, Thomas G. Lane.
 * Modified 2019 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
 * This file contains application interface routines that are used for both
 * compression and decompression.
 */

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


/*
 * Abort processing of a JPEG compression or decompression operation,
 * but don't destroy the object itself.
 *
 * For this, we merely clean up all the nonpermanent memory pools.
 * Note that temp files (virtual arrays) are not allowed to belong to
 * the permanent pool, so we will be able to close all temp files here.
 * Closing a data source or destination, if necessary, is the application's
 * responsibility.
 */

GLOBAL(void)
jpeg_abort (j_common_ptr cinfo)
{
  int pool;

  /* Do nothing if called on a not-initialized or destroyed JPEG object. */
  if (cinfo->mem == NULL)
    return;

  /* Releasing pools in reverse order might help avoid fragmentation
   * with some (brain-damaged) malloc libraries.
   */
  for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
    (*cinfo->mem->free_pool) (cinfo, pool);
  }

  /* Reset overall state for possible reuse of object */
  if (cinfo->is_decompressor) {
    cinfo->global_state = DSTATE_START;
    /* Try to keep application from accessing now-deleted marker list.
     * A bit kludgy to do it here, but this is the most central place.
     */
    ((j_decompress_ptr) cinfo)->marker_list = NULL;
  } else {
    cinfo->global_state = CSTATE_START;
  }
}


/*
 * Destruction of a JPEG object.
 *
 * Everything gets deallocated except the master jpeg_compress_struct itself
 * and the error manager struct.  Both of these are supplied by the application
 * and must be freed, if necessary, by the application.  (Often they are on
 * the stack and so don't need to be freed anyway.)
 * Closing a data source or destination, if necessary, is the application's
 * responsibility.
 */

GLOBAL(void)
jpeg_destroy (j_common_ptr cinfo)
{
  /* We need only tell the memory manager to release everything. */
  /* NB: mem pointer is NULL if memory mgr failed to initialize. */
  if (cinfo->mem != NULL)
    (*cinfo->mem->self_destruct) (cinfo);
  cinfo->mem = NULL;    /* be safe if jpeg_destroy is called twice */
  cinfo->global_state = 0;  /* mark it destroyed */
}


/*
 * Convenience routines for allocating quantization and Huffman tables.
 * (Would jutils.c be a more reasonable place to put these?)
 */

GLOBAL(JQUANT_TBL *)
jpeg_alloc_quant_table (j_common_ptr cinfo)
{
  JQUANT_TBL *tbl;

  tbl = (JQUANT_TBL *)
    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
  tbl->sent_table = FALSE;  /* make sure this is false in any new table */
  return tbl;
}


GLOBAL(JHUFF_TBL *)
jpeg_alloc_huff_table (j_common_ptr cinfo)
{
  JHUFF_TBL *tbl;

  tbl = (JHUFF_TBL *)
    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
  tbl->sent_table = FALSE;  /* make sure this is false in any new table */
  return tbl;
}


/*
 * Set up the standard Huffman tables (cf. JPEG standard section K.3).
 * IMPORTANT: these are only valid for 8-bit data precision!
 * (Would jutils.c be a more reasonable place to put this?)
 */

GLOBAL(JHUFF_TBL *)
jpeg_std_huff_table (j_common_ptr cinfo, boolean isDC, int tblno)
{
  JHUFF_TBL **htblptr, *htbl;
  const UINT8 *bits, *val;
  int nsymbols, len;

  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) {
    if (isDC)
      htblptr = ((j_decompress_ptr) cinfo)->dc_huff_tbl_ptrs;
    else
      htblptr = ((j_decompress_ptr) cinfo)->ac_huff_tbl_ptrs;
  } else {
    if (isDC)
      htblptr = ((j_compress_ptr) cinfo)->dc_huff_tbl_ptrs;
    else
      htblptr = ((j_compress_ptr) cinfo)->ac_huff_tbl_ptrs;
  }

  switch (tblno) {
  case 0:
    if (isDC) {
      bits = bits_dc_luminance;
      val = val_dc_luminance;
    } else {
      bits = bits_ac_luminance;
      val = val_ac_luminance;
    }
    break;
  case 1:
    if (isDC) {
      bits = bits_dc_chrominance;
      val = val_dc_chrominance;
    } else {
      bits = bits_ac_chrominance;
      val = val_ac_chrominance;
    }
    break;
  default:
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
    return NULL; /* avoid compiler warnings for uninitialized variables */
  }

  if (htblptr[tblno] == NULL)
    htblptr[tblno] = jpeg_alloc_huff_table(cinfo);

  htbl = htblptr[tblno];

  /* Copy the number-of-symbols-of-each-code-length counts */
  MEMCOPY(htbl->bits, bits, SIZEOF(htbl->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.  jxhuff.c will do a more thorough test later.
   */
  nsymbols = 0;
  for (len = 1; len <= 16; len++)
    nsymbols += bits[len];
  if (nsymbols > 256)
    ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);

  if (nsymbols > 0)
    MEMCOPY(htbl->huffval, val, nsymbols * SIZEOF(UINT8));

  /* Initialize sent_table FALSE so table will be written to JPEG file. */
  htbl->sent_table = FALSE;

  return htbl;
}

Coverage Report

Created: 2025-06-10 07:15

Line	Count	Source (jump to first uncovered line)
1		/*
2		* jcomapi.c
3		*
4		* Copyright (C) 1994-1997, Thomas G. Lane.
5		* Modified 2019 by Guido Vollbeding.
6		* This file is part of the Independent JPEG Group's software.
7		* For conditions of distribution and use, see the accompanying README file.
8		*
9		* This file contains application interface routines that are used for both
10		* compression and decompression.
11		*/
12
13		#define JPEG_INTERNALS
14		#include "jinclude.h"
15		#include "jpeglib.h"
16
17
18		/*
19		* Abort processing of a JPEG compression or decompression operation,
20		* but don't destroy the object itself.
21		*
22		* For this, we merely clean up all the nonpermanent memory pools.
23		* Note that temp files (virtual arrays) are not allowed to belong to
24		* the permanent pool, so we will be able to close all temp files here.
25		* Closing a data source or destination, if necessary, is the application's
26		* responsibility.
27		*/
28
29		GLOBAL(void)
30		jpeg_abort (j_common_ptr cinfo)
31	743	{
32	743	int pool;
33
34		/* Do nothing if called on a not-initialized or destroyed JPEG object. */
35	743	if (cinfo->mem == NULL)
36	0	return;
37
38		/* Releasing pools in reverse order might help avoid fragmentation
39		* with some (brain-damaged) malloc libraries.
40		*/
41	1.48k	for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
42	743	(*cinfo->mem->free_pool) (cinfo, pool);
43	743	}
44
45		/* Reset overall state for possible reuse of object */
46	743	if (cinfo->is_decompressor) {
47	742	cinfo->global_state = DSTATE_START;
48		/* Try to keep application from accessing now-deleted marker list.
49		* A bit kludgy to do it here, but this is the most central place.
50		*/
51	742	((j_decompress_ptr) cinfo)->marker_list = NULL;
52	742	} else {
53	1	cinfo->global_state = CSTATE_START;
54	1	}
55	743	}
56
57
58		/*
59		* Destruction of a JPEG object.
60		*
61		* Everything gets deallocated except the master jpeg_compress_struct itself
62		* and the error manager struct. Both of these are supplied by the application
63		* and must be freed, if necessary, by the application. (Often they are on
64		* the stack and so don't need to be freed anyway.)
65		* Closing a data source or destination, if necessary, is the application's
66		* responsibility.
67		*/
68
69		GLOBAL(void)
70		jpeg_destroy (j_common_ptr cinfo)
71	1.13k	{
72		/* We need only tell the memory manager to release everything. */
73		/* NB: mem pointer is NULL if memory mgr failed to initialize. */
74	1.13k	if (cinfo->mem != NULL)
75	1.13k	(*cinfo->mem->self_destruct) (cinfo);
76	1.13k	cinfo->mem = NULL; /* be safe if jpeg_destroy is called twice */
77	1.13k	cinfo->global_state = 0; /* mark it destroyed */
78	1.13k	}
79
80
81		/*
82		* Convenience routines for allocating quantization and Huffman tables.
83		* (Would jutils.c be a more reasonable place to put these?)
84		*/
85
86		GLOBAL(JQUANT_TBL *)
87		jpeg_alloc_quant_table (j_common_ptr cinfo)
88	1.70k	{
89	1.70k	JQUANT_TBL *tbl;
90
91	1.70k	tbl = (JQUANT_TBL *)
92	1.70k	(*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
93	1.70k	tbl->sent_table = FALSE; /* make sure this is false in any new table */
94	1.70k	return tbl;
95	1.70k	}
96
97
98		GLOBAL(JHUFF_TBL *)
99		jpeg_alloc_huff_table (j_common_ptr cinfo)
100	3.25k	{
101	3.25k	JHUFF_TBL *tbl;
102
103	3.25k	tbl = (JHUFF_TBL *)
104	3.25k	(*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
105	3.25k	tbl->sent_table = FALSE; /* make sure this is false in any new table */
106	3.25k	return tbl;
107	3.25k	}
108
109
110		/*
111		* Set up the standard Huffman tables (cf. JPEG standard section K.3).
112		* IMPORTANT: these are only valid for 8-bit data precision!
113		* (Would jutils.c be a more reasonable place to put this?)
114		*/
115
116		GLOBAL(JHUFF_TBL *)
117		jpeg_std_huff_table (j_common_ptr cinfo, boolean isDC, int tblno)
118	43	{
119	43	JHUFF_TBL *htblptr, htbl;
120	43	const UINT8 bits, val;
121	43	int nsymbols, len;
122
123	43	static const UINT8 bits_dc_luminance[17] =
124	43	{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
125	43	static const UINT8 val_dc_luminance[] =
126	43	{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
127
128	43	static const UINT8 bits_dc_chrominance[17] =
129	43	{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
130	43	static const UINT8 val_dc_chrominance[] =
131	43	{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
132
133	43	static const UINT8 bits_ac_luminance[17] =
134	43	{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
135	43	static const UINT8 val_ac_luminance[] =
136	43	{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
137	43	0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
138	43	0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
139	43	0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
140	43	0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
141	43	0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
142	43	0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
143	43	0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
144	43	0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
145	43	0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
146	43	0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
147	43	0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
148	43	0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
149	43	0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
150	43	0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
151	43	0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
152	43	0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
153	43	0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
154	43	0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
155	43	0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
156	43	0xf9, 0xfa };
157
158	43	static const UINT8 bits_ac_chrominance[17] =
159	43	{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
160	43	static const UINT8 val_ac_chrominance[] =
161	43	{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
162	43	0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
163	43	0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
164	43	0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
165	43	0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
166	43	0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
167	43	0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
168	43	0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
169	43	0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
170	43	0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
171	43	0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
172	43	0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
173	43	0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
174	43	0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
175	43	0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
176	43	0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
177	43	0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
178	43	0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
179	43	0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
180	43	0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
181	43	0xf9, 0xfa };
182
183	43	if (cinfo->is_decompressor) {
184	19	if (isDC)
185	6	htblptr = ((j_decompress_ptr) cinfo)->dc_huff_tbl_ptrs;
186	13	else
187	13	htblptr = ((j_decompress_ptr) cinfo)->ac_huff_tbl_ptrs;
188	24	} else {
189	24	if (isDC)
190	12	htblptr = ((j_compress_ptr) cinfo)->dc_huff_tbl_ptrs;
191	12	else
192	12	htblptr = ((j_compress_ptr) cinfo)->ac_huff_tbl_ptrs;
193	24	}
194
195	43	switch (tblno) {
196	21	case 0:
197	21	if (isDC) {
198	7	bits = bits_dc_luminance;
199	7	val = val_dc_luminance;
200	14	} else {
201	14	bits = bits_ac_luminance;
202	14	val = val_ac_luminance;
203	14	}
204	21	break;
205	22	case 1:
206	22	if (isDC) {
207	11	bits = bits_dc_chrominance;
208	11	val = val_dc_chrominance;
209	11	} else {
210	11	bits = bits_ac_chrominance;
211	11	val = val_ac_chrominance;
212	11	}
213	22	break;
214	0	default:
215	0	ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
216	0	return NULL; /* avoid compiler warnings for uninitialized variables */
217	43	}
218
219	43	if (htblptr[tblno] == NULL)
220	43	htblptr[tblno] = jpeg_alloc_huff_table(cinfo);
221
222	43	htbl = htblptr[tblno];
223
224		/* Copy the number-of-symbols-of-each-code-length counts */
225	43	MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
226
227		/* Validate the counts. We do this here mainly so we can copy the right
228		* number of symbols from the val[] array, without risking marching off
229		* the end of memory. jxhuff.c will do a more thorough test later.
230		*/
231	43	nsymbols = 0;
232	731	for (len = 1; len <= 16; len++)
233	688	nsymbols += bits[len];
234	43	if (nsymbols > 256)
235	0	ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
236
237	43	if (nsymbols > 0)
238	43	MEMCOPY(htbl->huffval, val, nsymbols * SIZEOF(UINT8));
239
240		/* Initialize sent_table FALSE so table will be written to JPEG file. */
241	43	htbl->sent_table = FALSE;
242
243	43	return htbl;
244	43	}