libs/jpeg/jcomapi.c

   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 {
  32   int pool;
  33
  34   /* Do nothing if called on a not-initialized or destroyed JPEG object. */
  35   if (cinfo->mem == NULL)
  36     return;
  37
  38   /* Releasing pools in reverse order might help avoid fragmentation
  39    * with some (brain-damaged) malloc libraries.
  40    */
  41   for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
  42     (*cinfo->mem->free_pool) (cinfo, pool);
  43   }
  44
  45   /* Reset overall state for possible reuse of object */
  46   if (cinfo->is_decompressor) {
  47     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     ((j_decompress_ptr) cinfo)->marker_list = NULL;
  52   } else {
  53     cinfo->global_state = CSTATE_START;
  54   }
  55 }
  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 {
  72   /* We need only tell the memory manager to release everything. */
  73   /* NB: mem pointer is NULL if memory mgr failed to initialize. */
  74   if (cinfo->mem != NULL)
  75     (*cinfo->mem->self_destruct) (cinfo);
  76   cinfo->mem = NULL;            /* be safe if jpeg_destroy is called twice */
  77   cinfo->global_state = 0;      /* mark it destroyed */
  78 }
  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 {
  89   JQUANT_TBL *tbl;
  90
  91   tbl = (JQUANT_TBL *)
  92     (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
  93   tbl->sent_table = FALSE;      /* make sure this is false in any new table */
  94   return tbl;
  95 }
  96
  97
  98 GLOBAL(JHUFF_TBL *)
  99 jpeg_alloc_huff_table (j_common_ptr cinfo)
 100 {
 101   JHUFF_TBL *tbl;
 102
 103   tbl = (JHUFF_TBL *)
 104     (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
 105   tbl->sent_table = FALSE;      /* make sure this is false in any new table */
 106   return tbl;
 107 }
 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 {
 119   JHUFF_TBL **htblptr, *htbl;
 120   const UINT8 *bits, *val;
 121   int nsymbols, len;
 122
 123   static const UINT8 bits_dc_luminance[17] =
 124     { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
 125   static const UINT8 val_dc_luminance[] =
 126     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 127
 128   static const UINT8 bits_dc_chrominance[17] =
 129     { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
 130   static const UINT8 val_dc_chrominance[] =
 131     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 132
 133   static const UINT8 bits_ac_luminance[17] =
 134     { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
 135   static const UINT8 val_ac_luminance[] =
 136     { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 137       0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 138       0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 139       0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 140       0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 141       0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 142       0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 143       0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 144       0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 145       0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 146       0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 147       0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 148       0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 149       0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 150       0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 151       0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 152       0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 153       0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 154       0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 155       0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 156       0xf9, 0xfa };
 157
 158   static const UINT8 bits_ac_chrominance[17] =
 159     { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 160   static const UINT8 val_ac_chrominance[] =
 161     { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 162       0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 163       0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 164       0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 165       0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 166       0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 167       0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 168       0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 169       0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 170       0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 171       0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 172       0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 173       0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 174       0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 175       0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 176       0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 177       0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 178       0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 179       0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 180       0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 181       0xf9, 0xfa };
 182
 183   if (cinfo->is_decompressor) {
 184     if (isDC)
 185       htblptr = ((j_decompress_ptr) cinfo)->dc_huff_tbl_ptrs;
 186     else
 187       htblptr = ((j_decompress_ptr) cinfo)->ac_huff_tbl_ptrs;
 188   } else {
 189     if (isDC)
 190       htblptr = ((j_compress_ptr) cinfo)->dc_huff_tbl_ptrs;
 191     else
 192       htblptr = ((j_compress_ptr) cinfo)->ac_huff_tbl_ptrs;
 193   }
 194
 195   switch (tblno) {
 196   case 0:
 197     if (isDC) {
 198       bits = bits_dc_luminance;
 199       val = val_dc_luminance;
 200     } else {
 201       bits = bits_ac_luminance;
 202       val = val_ac_luminance;
 203     }
 204     break;
 205   case 1:
 206     if (isDC) {
 207       bits = bits_dc_chrominance;
 208       val = val_dc_chrominance;
 209     } else {
 210       bits = bits_ac_chrominance;
 211       val = val_ac_chrominance;
 212     }
 213     break;
 214   default:
 215     ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
 216     return NULL; /* avoid compiler warnings for uninitialized variables */
 217   }
 218
 219   if (htblptr[tblno] == NULL)
 220     htblptr[tblno] = jpeg_alloc_huff_table(cinfo);
 221
 222   htbl = htblptr[tblno];
 223
 224   /* Copy the number-of-symbols-of-each-code-length counts */
 225   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   nsymbols = 0;
 232   for (len = 1; len <= 16; len++)
 233     nsymbols += bits[len];
 234   if (nsymbols > 256)
 235     ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
 236
 237   if (nsymbols > 0)
 238     MEMCOPY(htbl->huffval, val, nsymbols * SIZEOF(UINT8));
 239
 240   /* Initialize sent_table FALSE so table will be written to JPEG file. */
 241   htbl->sent_table = FALSE;
 242
 243   return htbl;
 244 }