libjpeg-turbo10-rh639672.patch

   1 From 195345e454d3df7ff9c07c3d36881ec52e789af2 Mon Sep 17 00:00:00 2001
   2 From: Mukund Sivaraman <muks@banu.com>
   3 Date: Sun, 3 Oct 2010 12:23:41 +0530
   4 Subject: [PATCH] Add support for decoding arithmetic coded content
   5
   6 This is based on a patch by Guido Vollbeding <guivol@esc.de>, which
   7 included code to both encode and decode arithmetic coded content.
   8
   9 This patch only adds the decoding portion. No new arithmetic coded
  10 content can be produced, but existing arithmetic coded content can
  11 be decoded.
  12
  13 libjpeg-turbo with this patch has been tested with some arithmetic
  14 coded images (digital photographs).
  15 ---
  16  Makefile.am       |   17 +-
  17  README.arithmetic |  215 +++++++++++++++
  18  jaricom.c         |  149 +++++++++++
  19  jdarith.c         |  762 +++++++++++++++++++++++++++++++++++++++++++++++++++++
  20  jdmaster.c        |    2 +-
  21  jdtrans.c         |    2 +-
  22  jerror.h          |    2 +
  23  jmorecfg.h        |    2 +-
  24  jpegint.h         |    2 +
  25  9 files changed, 1142 insertions(+), 11 deletions(-)
  26  create mode 100644 README.arithmetic
  27  create mode 100644 jaricom.c
  28  create mode 100644 jdarith.c
  29
  30 diff --git a/Makefile.am b/Makefile.am
  31 index f8552ea..1eee598 100644
  32 --- a/Makefile.am
  33 +++ b/Makefile.am
  34 @@ -7,14 +7,15 @@ nodist_include_HEADERS = jconfig.h
  35  HDRS = jchuff.h jdct.h jdhuff.h jerror.h jinclude.h jmemsys.h jmorecfg.h \
  36         jpegint.h jpeglib.h jversion.h jsimd.h jsimddct.h
  37
  38 -libjpeg_la_SOURCES = $(HDRS) jcapimin.c jcapistd.c jccoefct.c jccolor.c \
  39 -       jcdctmgr.c jchuff.c jcinit.c jcmainct.c jcmarker.c jcmaster.c \
  40 -       jcomapi.c jcparam.c jcphuff.c jcprepct.c jcsample.c jctrans.c \
  41 -       jdapimin.c jdapistd.c jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c \
  42 -       jddctmgr.c jdhuff.c jdinput.c jdmainct.c jdmarker.c jdmaster.c \
  43 -       jdmerge.c jdphuff.c jdpostct.c jdsample.c jdtrans.c jerror.c \
  44 -       jfdctflt.c jfdctfst.c jfdctint.c jidctflt.c jidctfst.c jidctint.c \
  45 -       jidctred.c jquant1.c jquant2.c jutils.c jmemmgr.c jmemnobs.c
  46 +libjpeg_la_SOURCES = $(HDRS) jaricom.c jcapimin.c jcapistd.c           \
  47 +       jccoefct.c jccolor.c jcdctmgr.c jchuff.c jcinit.c jcmainct.c    \
  48 +       jcmarker.c jcmaster.c jcomapi.c jcparam.c jcphuff.c jcprepct.c  \
  49 +       jcsample.c jctrans.c jdapimin.c jdapistd.c jdarith.c            \
  50 +       jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c jddctmgr.c jdhuff.c  \
  51 +       jdinput.c jdmainct.c jdmarker.c jdmaster.c jdmerge.c jdphuff.c  \
  52 +       jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c jfdctfst.c  \
  53 +       jfdctint.c jidctflt.c jidctfst.c jidctint.c jidctred.c          \
  54 +       jquant1.c jquant2.c jutils.c jmemmgr.c jmemnobs.c
  55
  56  libturbojpeg_la_SOURCES = $(libjpeg_la_SOURCES) turbojpegl.c turbojpeg.h \
  57         turbojpeg-mapfile
  58 diff --git a/README.arithmetic b/README.arithmetic
  59 new file mode 100644
  60 index 0000000..0dd3b9a
  61 --- /dev/null
  62 +++ b/README.arithmetic
  63 @@ -0,0 +1,215 @@
  64 +JPEG arithmetic encoding and decoding portable software implementation
  65 +======================================================================
  66 +
  67 +Release of 28-Mar-98 by Guido Vollbeding <guido@jpegclub.org>
  68 +=============================================================
  69 +
  70 +Primary URLs:
  71 +
  72 +       http://sylvana.net/jpeg-ari/
  73 +       (directory containing the actual archive files:)
  74 +
  75 +       http://sylvana.net/jpeg-ari/jpeg-ari-28mar98.tar.gz
  76 +
  77 +       http://sylvana.net/jpeg-ari/jpeg-ari.zip
  78 +
  79 +
  80 +DISCLAIMER
  81 +==========
  82 +
  83 +This package is distributed in the hope that it will be useful,
  84 +but WITHOUT ANY WARRANTY; without even the implied warranty of
  85 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  86 +
  87 +It is possible that certain products which can be built using this
  88 +software modules might form inventions protected by patent rights in
  89 +some countries (e.g. by patents about arithmetic coding algorithms
  90 +owned by IBM and AT&T in the USA). Provision of this software by the
  91 +author does NOT include any licenses for any patents.
  92 +In those countries where a patent license is required for certain
  93 +applications of this software modules, you will have to obtain such
  94 +a license yourself.
  95 +
  96 +See Annex L in the JPEG spec for further information
  97 +and a list of relevant patents.
  98 +
  99 +
 100 +What is it?
 101 +===========
 102 +
 103 +This is my implementation of the arithmetic encoding and decoding
 104 +back-end for JPEG as specified in the
 105 +
 106 +  ISO/IEC International Standard 10918-1 and CCITT Recommendation
 107 +  ITU-T T.81, "Information Technology - Digital Compression and
 108 +  Coding of Continuous-tone Still Images, Part 1: Requirements
 109 +  and Guidelines".
 110 +
 111 +Arithmetic coding is a state-of-the-art lossless entropy data
 112 +compression method which offers better compression performance
 113 +than the well-established Huffman entropy coding process.
 114 +
 115 +The JPEG standard specifies a particular arithmetic coding scheme
 116 +to be used optionally as alternative to Huffman coding.
 117 +
 118 +
 119 +Who needs it?
 120 +=============
 121 +
 122 +This package might be of interest for people who are looking for
 123 +enhanced state-of-the-art image compression technologies.
 124 +
 125 +It is intended to provide a reasonable tool for experimental,
 126 +comparison and evaluation purposes.
 127 +
 128 +See the Disclaimer above for restricted conditions of usage.
 129 +
 130 +
 131 +How does it work?
 132 +=================
 133 +
 134 +This distribution is organized as add-on to the widespread
 135 +Independent JPEG Group's JPEG software.
 136 +
 137 +Thus, once you managed to install the IJG software distribution
 138 +successfully, there should be no additional problems (portability
 139 +issues etc.) to incorporate this package into the library,
 140 +and usage is straightforward.
 141 +
 142 +Transcode given JPEG files simply with a command like
 143 +
 144 +  jpegtran -arithmetic [-progressive] < orig.jpg > arit.jpg
 145 +
 146 +into an arithmetic coded version LOSSLESSLY! Since there are
 147 +practically no applications in existence which can handle such
 148 +files, you can only transform it back with the same tool
 149 +
 150 +  jpegtran [-optimize] [-progressive] < arit.jpg > orig2.jpg
 151 +
 152 +to verify correct operation.
 153 +
 154 +Thus, you can easily verify the enhanced compression performance
 155 +of the arithmetic coding version compared to the Huffman (with
 156 +fixed or custom tables) version.
 157 +
 158 +The claim to evaluate was that arithmetic coding gives an average
 159 +5-10% compression improvement against Huffman.
 160 +Early tests with this implementation support this claim, and you
 161 +can perform tests with own material.
 162 +
 163 +Here are some actual results:
 164 +
 165 +% ./jpegtran -optimize < testorig.jpg > testopt.jpg
 166 +% ./jpegtran -arithmetic < testorig.jpg > testarit.jpg
 167 +% ./jpegtran < testarit.jpg > testorig2.jpg
 168 +% ./jpegtran -arithmetic -progressive < testorig.jpg > testaritp.jpg
 169 +% ./jpegtran < testaritp.jpg > testorig3.jpg
 170 +% ./jpegtran -optimize < ../butterfly.jpg > ../buttopt.jpg
 171 +% ./jpegtran -progressive < ../butterfly.jpg > ../buttprog.jpg
 172 +% ./jpegtran -arithmetic < ../butterfly.jpg > ../buttarit.jpg
 173 +% ./jpegtran < ../buttarit.jpg > ../butterfly2.jpg
 174 +% ./jpegtran -arithmetic -progressive < ../butterfly.jpg > ../buttaritp.jpg
 175 +% ./jpegtran < ../buttaritp.jpg > ../butterfly3.jpg
 176 +% ls -l test*.jpg
 177 +-rw-r--r--  1 guivol       5153 Apr 13 18:51 testarit.jpg
 178 +-rw-r--r--  1 guivol       5186 Apr 13 18:51 testaritp.jpg
 179 +-rw-r--r--  1 guivol       5756 Apr  2 15:10 testimg.jpg
 180 +-rw-r--r--  1 guivol       5645 Apr  2 15:10 testimgp.jpg
 181 +-rw-r--r--  1 guivol       5463 Apr 13 18:51 testopt.jpg
 182 +-rw-r--r--  1 guivol       5770 Apr  2 15:10 testorig.jpg
 183 +-rw-r--r--  1 guivol       5770 Apr 13 18:51 testorig2.jpg
 184 +-rw-r--r--  1 guivol       5770 Apr 13 18:51 testorig3.jpg
 185 +-rw-r--r--  1 guivol       5655 Apr  2 15:10 testprog.jpg
 186 +% ls -l ../butt*.jpg
 187 +-rw-r--r--  1 guivol     460091 Apr 13 18:52 ../buttarit.jpg
 188 +-rw-r--r--  1 guivol     453703 Apr 13 18:52 ../buttaritp.jpg
 189 +-rw-r--r--  1 guivol     527823 Nov 19 18:41 ../butterfly.jpg
 190 +-rw-r--r--  1 guivol     527823 Apr 13 18:52 ../butterfly2.jpg
 191 +-rw-r--r--  1 guivol     527823 Apr 13 18:52 ../butterfly3.jpg
 192 +-rw-r--r--  1 guivol     511834 Apr 13 18:52 ../buttopt.jpg
 193 +-rw-r--r--  1 guivol     492237 Apr 13 18:52 ../buttprog.jpg
 194 +%
 195 +
 196 +Note that arithmetic coding requires only a single processing
 197 +pass due to its fully-adaptive nature, and compared to one-pass
 198 +(fixed tables) Huffman the arithmetic coded version consistently
 199 +achieves 10% compression improvement.
 200 +Compared with two-pass (custom tables) Huffman the improvement
 201 +is 5-10%.
 202 +
 203 +Note that I wasn't able yet to cross-check interoperability of
 204 +the produced files with other implementations.
 205 +Thus, I can't be sure that the files are compliant to the spec,
 206 +but I hope so and the tests support it.
 207 +The encoding and decoding processes should be correct anyway,
 208 +however, in the sense that they are complementary to each other
 209 +and thus retain data integrity.
 210 +
 211 +I would appreciate any indications for compliance or interoperability
 212 +with other implementations from somebody.
 213 +Please let me know if you are able to cross-check something.
 214 +
 215 +
 216 +Installation
 217 +============
 218 +
 219 +The installation is a 2-stage procedure:
 220 +
 221 +1. Preparing the IJG package for potential incorporation
 222 +   of the arithmetic coding feature.
 223 +
 224 +2. Incorporation of the actual arithmetic coding modules
 225 +   and enabling the feature for usage.
 226 +
 227 +The reason for this 2-stage process is the hope to make
 228 +step 1 obsolete in future IJG releases.
 229 +The actual implementation should remain separate IMHO due
 230 +to the different usage conditions.
 231 +
 232 +Step 1:
 233 +
 234 +1.1. Copy all files from the subdirectory 'patchv6b' into
 235 +     the IJG software's v6b source directory.
 236 +     This includes minor patches to some files and 3 extra
 237 +     files which hold place for the actual implementation.
 238 +
 239 +1.2. Update your Makefile/Projectfile for the inclusion of
 240 +     the 3 extra files. This will be done automatically
 241 +     if you use a configure-generated makefile and type
 242 +     './configure' (reconfigure).
 243 +
 244 +1.3. Recompile ('make').
 245 +
 246 +See the file 'PATCHES' in 'patchv6b' for details.
 247 +
 248 +Step 2:
 249 +
 250 +2.1. Replace the 3 placeholder files by the actual implementation
 251 +     modules.
 252 +
 253 +2.2. Enable application support of the new features by #defining
 254 +     C_ARITH_CODING_SUPPORTED and D_ARITH_CODING_SUPPORTED
 255 +     in 'jmorecfg.h'.
 256 +
 257 +2.3. Recompile ('make').
 258 +
 259 +Note that I suggest to add 3 placeholder files to the IJG
 260 +distribution. This would remove the need for system-dependent
 261 +changes (Makefiles) and thus considerably simplify the actual
 262 +installation for systems without a configure-generated makefile.
 263 +
 264 +
 265 +References
 266 +==========
 267 +
 268 +- The Independent JPEG Group's software
 269 +
 270 +- JBIG-KIT lossless image compression library by Markus Kuhn
 271 +
 272 +- William B. Pennebaker, Joan L. Mitchell:
 273 +  "JPEG Still Image Data Compression Standard",
 274 +  Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
 275 +
 276 +- jpeg-faq (http://www.faqs.org/faqs/jpeg-faq/)
 277 +
 278 +- compression-faq (http://www.faqs.org/faqs/compression-faq/)
 279 diff --git a/jaricom.c b/jaricom.c
 280 new file mode 100644
 281 index 0000000..e4292b0
 282 --- /dev/null
 283 +++ b/jaricom.c
 284 @@ -0,0 +1,149 @@
 285 +/*
 286 + * jaricom.c
 287 + *
 288 + * Copyright (C) 1997, Guido Vollbeding <guivol@esc.de>.
 289 + * This file is NOT part of the Independent JPEG Group's software
 290 + * for legal reasons.
 291 + * See the accompanying README file for conditions of distribution and use.
 292 + *
 293 + * This file contains probability estimation tables for common use in
 294 + * arithmetic entropy encoding and decoding routines.
 295 + *
 296 + * This data represents Table D.2 in the JPEG spec (ISO/IEC IS 10918-1
 297 + * and CCITT Recommendation ITU-T T.81) and Table 24 in the JBIG spec
 298 + * (ISO/IEC IS 11544 and CCITT Recommendation ITU-T T.82).
 299 + */
 300 +
 301 +#define JPEG_INTERNALS
 302 +#include "jinclude.h"
 303 +#include "jpeglib.h"
 304 +
 305 +/* The following #define specifies the packing of the four components
 306 + * into the compact INT32 representation.
 307 + * Note that this formula must match the actual arithmetic encoder
 308 + * and decoder implementation. The implementation has to be changed
 309 + * if this formula is changed.
 310 + * The current organisation is leaned on Markus Kuhn's JBIG
 311 + * implementation (jbig_tab.c).
 312 + */
 313 +
 314 +#define V(a,b,c,d) (((INT32)a << 16) | ((INT32)c << 8) | ((INT32)d << 7) | b)
 315 +
 316 +const INT32 jaritab[113] = {
 317 +/*
 318 + * Index, Qe_Value, Next_Index_LPS, Next_Index_MPS, Switch_MPS
 319 + */
 320 +/*   0 */  V( 0x5a1d,   1,   1, 1 ),
 321 +/*   1 */  V( 0x2586,  14,   2, 0 ),
 322 +/*   2 */  V( 0x1114,  16,   3, 0 ),
 323 +/*   3 */  V( 0x080b,  18,   4, 0 ),
 324 +/*   4 */  V( 0x03d8,  20,   5, 0 ),
 325 +/*   5 */  V( 0x01da,  23,   6, 0 ),
 326 +/*   6 */  V( 0x00e5,  25,   7, 0 ),
 327 +/*   7 */  V( 0x006f,  28,   8, 0 ),
 328 +/*   8 */  V( 0x0036,  30,   9, 0 ),
 329 +/*   9 */  V( 0x001a,  33,  10, 0 ),
 330 +/*  10 */  V( 0x000d,  35,  11, 0 ),
 331 +/*  11 */  V( 0x0006,   9,  12, 0 ),
 332 +/*  12 */  V( 0x0003,  10,  13, 0 ),
 333 +/*  13 */  V( 0x0001,  12,  13, 0 ),
 334 +/*  14 */  V( 0x5a7f,  15,  15, 1 ),
 335 +/*  15 */  V( 0x3f25,  36,  16, 0 ),
 336 +/*  16 */  V( 0x2cf2,  38,  17, 0 ),
 337 +/*  17 */  V( 0x207c,  39,  18, 0 ),
 338 +/*  18 */  V( 0x17b9,  40,  19, 0 ),
 339 +/*  19 */  V( 0x1182,  42,  20, 0 ),
 340 +/*  20 */  V( 0x0cef,  43,  21, 0 ),
 341 +/*  21 */  V( 0x09a1,  45,  22, 0 ),
 342 +/*  22 */  V( 0x072f,  46,  23, 0 ),
 343 +/*  23 */  V( 0x055c,  48,  24, 0 ),
 344 +/*  24 */  V( 0x0406,  49,  25, 0 ),
 345 +/*  25 */  V( 0x0303,  51,  26, 0 ),
 346 +/*  26 */  V( 0x0240,  52,  27, 0 ),
 347 +/*  27 */  V( 0x01b1,  54,  28, 0 ),
 348 +/*  28 */  V( 0x0144,  56,  29, 0 ),
 349 +/*  29 */  V( 0x00f5,  57,  30, 0 ),
 350 +/*  30 */  V( 0x00b7,  59,  31, 0 ),
 351 +/*  31 */  V( 0x008a,  60,  32, 0 ),
 352 +/*  32 */  V( 0x0068,  62,  33, 0 ),
 353 +/*  33 */  V( 0x004e,  63,  34, 0 ),
 354 +/*  34 */  V( 0x003b,  32,  35, 0 ),
 355 +/*  35 */  V( 0x002c,  33,   9, 0 ),
 356 +/*  36 */  V( 0x5ae1,  37,  37, 1 ),
 357 +/*  37 */  V( 0x484c,  64,  38, 0 ),
 358 +/*  38 */  V( 0x3a0d,  65,  39, 0 ),
 359 +/*  39 */  V( 0x2ef1,  67,  40, 0 ),
 360 +/*  40 */  V( 0x261f,  68,  41, 0 ),
 361 +/*  41 */  V( 0x1f33,  69,  42, 0 ),
 362 +/*  42 */  V( 0x19a8,  70,  43, 0 ),
 363 +/*  43 */  V( 0x1518,  72,  44, 0 ),
 364 +/*  44 */  V( 0x1177,  73,  45, 0 ),
 365 +/*  45 */  V( 0x0e74,  74,  46, 0 ),
 366 +/*  46 */  V( 0x0bfb,  75,  47, 0 ),
 367 +/*  47 */  V( 0x09f8,  77,  48, 0 ),
 368 +/*  48 */  V( 0x0861,  78,  49, 0 ),
 369 +/*  49 */  V( 0x0706,  79,  50, 0 ),
 370 +/*  50 */  V( 0x05cd,  48,  51, 0 ),
 371 +/*  51 */  V( 0x04de,  50,  52, 0 ),
 372 +/*  52 */  V( 0x040f,  50,  53, 0 ),
 373 +/*  53 */  V( 0x0363,  51,  54, 0 ),
 374 +/*  54 */  V( 0x02d4,  52,  55, 0 ),
 375 +/*  55 */  V( 0x025c,  53,  56, 0 ),
 376 +/*  56 */  V( 0x01f8,  54,  57, 0 ),
 377 +/*  57 */  V( 0x01a4,  55,  58, 0 ),
 378 +/*  58 */  V( 0x0160,  56,  59, 0 ),
 379 +/*  59 */  V( 0x0125,  57,  60, 0 ),
 380 +/*  60 */  V( 0x00f6,  58,  61, 0 ),
 381 +/*  61 */  V( 0x00cb,  59,  62, 0 ),
 382 +/*  62 */  V( 0x00ab,  61,  63, 0 ),
 383 +/*  63 */  V( 0x008f,  61,  32, 0 ),
 384 +/*  64 */  V( 0x5b12,  65,  65, 1 ),
 385 +/*  65 */  V( 0x4d04,  80,  66, 0 ),
 386 +/*  66 */  V( 0x412c,  81,  67, 0 ),
 387 +/*  67 */  V( 0x37d8,  82,  68, 0 ),
 388 +/*  68 */  V( 0x2fe8,  83,  69, 0 ),
 389 +/*  69 */  V( 0x293c,  84,  70, 0 ),
 390 +/*  70 */  V( 0x2379,  86,  71, 0 ),
 391 +/*  71 */  V( 0x1edf,  87,  72, 0 ),
 392 +/*  72 */  V( 0x1aa9,  87,  73, 0 ),
 393 +/*  73 */  V( 0x174e,  72,  74, 0 ),
 394 +/*  74 */  V( 0x1424,  72,  75, 0 ),
 395 +/*  75 */  V( 0x119c,  74,  76, 0 ),
 396 +/*  76 */  V( 0x0f6b,  74,  77, 0 ),
 397 +/*  77 */  V( 0x0d51,  75,  78, 0 ),
 398 +/*  78 */  V( 0x0bb6,  77,  79, 0 ),
 399 +/*  79 */  V( 0x0a40,  77,  48, 0 ),
 400 +/*  80 */  V( 0x5832,  80,  81, 1 ),
 401 +/*  81 */  V( 0x4d1c,  88,  82, 0 ),
 402 +/*  82 */  V( 0x438e,  89,  83, 0 ),
 403 +/*  83 */  V( 0x3bdd,  90,  84, 0 ),
 404 +/*  84 */  V( 0x34ee,  91,  85, 0 ),
 405 +/*  85 */  V( 0x2eae,  92,  86, 0 ),
 406 +/*  86 */  V( 0x299a,  93,  87, 0 ),
 407 +/*  87 */  V( 0x2516,  86,  71, 0 ),
 408 +/*  88 */  V( 0x5570,  88,  89, 1 ),
 409 +/*  89 */  V( 0x4ca9,  95,  90, 0 ),
 410 +/*  90 */  V( 0x44d9,  96,  91, 0 ),
 411 +/*  91 */  V( 0x3e22,  97,  92, 0 ),
 412 +/*  92 */  V( 0x3824,  99,  93, 0 ),
 413 +/*  93 */  V( 0x32b4,  99,  94, 0 ),
 414 +/*  94 */  V( 0x2e17,  93,  86, 0 ),
 415 +/*  95 */  V( 0x56a8,  95,  96, 1 ),
 416 +/*  96 */  V( 0x4f46, 101,  97, 0 ),
 417 +/*  97 */  V( 0x47e5, 102,  98, 0 ),
 418 +/*  98 */  V( 0x41cf, 103,  99, 0 ),
 419 +/*  99 */  V( 0x3c3d, 104, 100, 0 ),
 420 +/* 100 */  V( 0x375e,  99,  93, 0 ),
 421 +/* 101 */  V( 0x5231, 105, 102, 0 ),
 422 +/* 102 */  V( 0x4c0f, 106, 103, 0 ),
 423 +/* 103 */  V( 0x4639, 107, 104, 0 ),
 424 +/* 104 */  V( 0x415e, 103,  99, 0 ),
 425 +/* 105 */  V( 0x5627, 105, 106, 1 ),
 426 +/* 106 */  V( 0x50e7, 108, 107, 0 ),
 427 +/* 107 */  V( 0x4b85, 109, 103, 0 ),
 428 +/* 108 */  V( 0x5597, 110, 109, 0 ),
 429 +/* 109 */  V( 0x504f, 111, 107, 0 ),
 430 +/* 110 */  V( 0x5a10, 110, 111, 1 ),
 431 +/* 111 */  V( 0x5522, 112, 109, 0 ),
 432 +/* 112 */  V( 0x59eb, 112, 111, 1 )
 433 +};
 434 diff --git a/jdarith.c b/jdarith.c
 435 new file mode 100644
 436 index 0000000..1ef513e
 437 --- /dev/null
 438 +++ b/jdarith.c
 439 @@ -0,0 +1,762 @@
 440 +/*
 441 + * jdarith.c
 442 + *
 443 + * Copyright (C) 1997, Guido Vollbeding <guivol@esc.de>.
 444 + * This file is NOT part of the Independent JPEG Group's software
 445 + * for legal reasons.
 446 + * See the accompanying README file for conditions of distribution and use.
 447 + *
 448 + * This file contains portable arithmetic entropy decoding routines for JPEG
 449 + * (implementing the ISO/IEC IS 10918-1 and CCITT Recommendation ITU-T T.81).
 450 + *
 451 + * Both sequential and progressive modes are supported in this single module.
 452 + *
 453 + * Suspension is not currently supported in this module.
 454 + */
 455 +
 456 +#define JPEG_INTERNALS
 457 +#include "jinclude.h"
 458 +#include "jpeglib.h"
 459 +
 460 +
 461 +/* Expanded entropy decoder object for arithmetic decoding. */
 462 +
 463 +typedef struct {
 464 +  struct jpeg_entropy_decoder pub; /* public fields */
 465 +
 466 +  INT32 c;       /* C register, base of coding interval + input bit buffer */
 467 +  INT32 a;               /* A register, normalized size of coding interval */
 468 +  int ct;     /* bit shift counter, # of bits left in bit buffer part of C */
 469 +                                                         /* init: ct = -16 */
 470 +                                                         /* run: ct = 0..7 */
 471 +                                                         /* error: ct = -1 */
 472 +  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
 473 +  int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
 474 +
 475 +  unsigned int restarts_to_go; /* MCUs left in this restart interval */
 476 +
 477 +  /* Pointers to statistics areas (these workspaces have image lifespan) */
 478 +  unsigned char * dc_stats[NUM_ARITH_TBLS];
 479 +  unsigned char * ac_stats[NUM_ARITH_TBLS];
 480 +} arith_entropy_decoder;
 481 +
 482 +typedef arith_entropy_decoder * arith_entropy_ptr;
 483 +
 484 +/* The following two definitions specify the allocation chunk size
 485 + * for the statistics area.
 486 + * According to sections F.1.4.4.1.3 and F.1.4.4.2, we need at least
 487 + * 49 statistics bins for DC, and 245 statistics bins for AC coding.
 488 + * Note that we use one additional AC bin for codings with fixed
 489 + * probability (0.5), thus the minimum number for AC is 246.
 490 + *
 491 + * We use a compact representation with 1 byte per statistics bin,
 492 + * thus the numbers directly represent byte sizes.
 493 + * This 1 byte per statistics bin contains the meaning of the MPS
 494 + * (more probable symbol) in the highest bit (mask 0x80), and the
 495 + * index into the probability estimation state machine table
 496 + * in the lower bits (mask 0x7F).
 497 + */
 498 +
 499 +#define DC_STAT_BINS 64
 500 +#define AC_STAT_BINS 256
 501 +
 502 +
 503 +LOCAL(int)
 504 +get_byte (j_decompress_ptr cinfo)
 505 +/* Read next input byte; we do not support suspension in this module. */
 506 +{
 507 +  struct jpeg_source_mgr * src = cinfo->src;
 508 +
 509 +  if (src->bytes_in_buffer == 0)
 510 +    if (! (*src->fill_input_buffer) (cinfo))
 511 +      ERREXIT(cinfo, JERR_CANT_SUSPEND);
 512 +  src->bytes_in_buffer--;
 513 +  return GETJOCTET(*src->next_input_byte++);
 514 +}
 515 +
 516 +
 517 +/*
 518 + * The core arithmetic decoding routine (common in JPEG and JBIG).
 519 + * This needs to go as fast as possible.
 520 + * Machine-dependent optimization facilities
 521 + * are not utilized in this portable implementation.
 522 + * However, this code should be fairly efficient and
 523 + * may be a good base for further optimizations anyway.
 524 + *
 525 + * Return value is 0 or 1 (binary decision).
 526 + *
 527 + * Note: I've changed the handling of the code base & bit
 528 + * buffer register C compared to other implementations
 529 + * based on the standards layout & procedures.
 530 + * While it also contains both the actual base of the
 531 + * coding interval (16 bits) and the next-bits buffer,
 532 + * the cut-point between these two parts is floating
 533 + * (instead of fixed) with the bit shift counter CT.
 534 + * Thus, we also need only one (variable instead of
 535 + * fixed size) shift for the LPS/MPS decision, and
 536 + * we can get away with any renormalization update
 537 + * of C (except for new data insertion, of course).
 538 + *
 539 + * I've also introduced a new scheme for accessing
 540 + * the probability estimation state machine table,
 541 + * derived from Markus Kuhn's JBIG implementation.
 542 + */
 543 +
 544 +LOCAL(int)
 545 +arith_decode (j_decompress_ptr cinfo, unsigned char *st)
 546 +{
 547 +  extern const INT32 jaritab[];
 548 +  register arith_entropy_ptr e = (arith_entropy_ptr) cinfo->entropy;
 549 +  register unsigned char nl, nm;
 550 +  register INT32 qe, temp;
 551 +  register int sv, data;
 552 +
 553 +  /* Renormalization & data input per section D.2.6 */
 554 +  while (e->a < 0x8000L) {
 555 +    if (--e->ct < 0) {
 556 +      /* Need to fetch next data byte */
 557 +      if (cinfo->unread_marker)
 558 +       data = 0;               /* stuff zero data */
 559 +      else {
 560 +       data = get_byte(cinfo); /* read next input byte */
 561 +       if (data == 0xFF) {     /* zero stuff or marker code */
 562 +         do data = get_byte(cinfo);
 563 +         while (data == 0xFF); /* swallow extra 0xFF bytes */
 564 +         if (data == 0)
 565 +           data = 0xFF;        /* discard stuffed zero byte */
 566 +         else {
 567 +           /* Note: Different from the Huffman decoder, hitting
 568 +            * a marker while processing the compressed data
 569 +            * segment is legal in arithmetic coding.
 570 +            * The convention is to supply zero data
 571 +            * then until decoding is complete.
 572 +            */
 573 +           cinfo->unread_marker = data;
 574 +           data = 0;
 575 +         }
 576 +       }
 577 +      }
 578 +      e->c = (e->c << 8) | data; /* insert data into C register */
 579 +      if ((e->ct += 8) < 0)     /* update bit shift counter */
 580 +       /* Need more initial bytes */
 581 +       if (++e->ct == 0)
 582 +         /* Got 2 initial bytes -> re-init A and exit loop */
 583 +         e->a = 0x8000L; /* => e->a = 0x10000L after loop exit */
 584 +    }
 585 +    e->a <<= 1;
 586 +  }
 587 +
 588 +  /* Fetch values from our compact representation of Table D.2:
 589 +   * Qe values and probability estimation state machine
 590 +   */
 591 +  sv = *st;
 592 +  qe = jaritab[sv & 0x7F];     /* => Qe_Value */
 593 +  nl = qe & 0xFF; qe >>= 8;    /* Next_Index_LPS + Switch_MPS */
 594 +  nm = qe & 0xFF; qe >>= 8;    /* Next_Index_MPS */
 595 +
 596 +  /* Decode & estimation procedures per sections D.2.4 & D.2.5 */
 597 +  temp = e->a - qe;
 598 +  e->a = temp;
 599 +  temp <<= e->ct;
 600 +  if (e->c >= temp) {
 601 +    e->c -= temp;
 602 +    /* Conditional LPS (less probable symbol) exchange */
 603 +    if (e->a < qe) {
 604 +      e->a = qe;
 605 +      *st = (sv & 0x80) ^ nm;  /* Estimate_after_MPS */
 606 +    } else {
 607 +      e->a = qe;
 608 +      *st = (sv & 0x80) ^ nl;  /* Estimate_after_LPS */
 609 +      sv ^= 0x80;              /* Exchange LPS/MPS */
 610 +    }
 611 +  } else if (e->a < 0x8000L) {
 612 +    /* Conditional MPS (more probable symbol) exchange */
 613 +    if (e->a < qe) {
 614 +      *st = (sv & 0x80) ^ nl;  /* Estimate_after_LPS */
 615 +      sv ^= 0x80;              /* Exchange LPS/MPS */
 616 +    } else {
 617 +      *st = (sv & 0x80) ^ nm;  /* Estimate_after_MPS */
 618 +    }
 619 +  }
 620 +
 621 +  return sv >> 7;
 622 +}
 623 +
 624 +
 625 +/*
 626 + * Check for a restart marker & resynchronize decoder.
 627 + */
 628 +
 629 +LOCAL(void)
 630 +process_restart (j_decompress_ptr cinfo)
 631 +{
 632 +  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
 633 +  int ci;
 634 +  jpeg_component_info * compptr;
 635 +
 636 +  /* Advance past the RSTn marker */
 637 +  if (! (*cinfo->marker->read_restart_marker) (cinfo))
 638 +    ERREXIT(cinfo, JERR_CANT_SUSPEND);
 639 +
 640 +  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 641 +    compptr = cinfo->cur_comp_info[ci];
 642 +    /* Re-initialize statistics areas */
 643 +    if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
 644 +      MEMZERO(entropy->dc_stats[compptr->dc_tbl_no], DC_STAT_BINS);
 645 +      /* Reset DC predictions to 0 */
 646 +      entropy->last_dc_val[ci] = 0;
 647 +      entropy->dc_context[ci] = 0;
 648 +    }
 649 +    if (cinfo->progressive_mode == 0 || cinfo->Ss) {
 650 +      MEMZERO(entropy->ac_stats[compptr->ac_tbl_no], AC_STAT_BINS);
 651 +    }
 652 +  }
 653 +
 654 +  /* Reset arithmetic decoding variables */
 655 +  entropy->c = 0;
 656 +  entropy->a = 0;
 657 +  entropy->ct = -16;   /* force reading 2 initial bytes to fill C */
 658 +
 659 +  /* Reset restart counter */
 660 +  entropy->restarts_to_go = cinfo->restart_interval;
 661 +}
 662 +
 663 +
 664 +/*
 665 + * Arithmetic MCU decoding.
 666 + * Each of these routines decodes and returns one MCU's worth of
 667 + * arithmetic-compressed coefficients.
 668 + * The coefficients are reordered from zigzag order into natural array order,
 669 + * but are not dequantized.
 670 + *
 671 + * The i'th block of the MCU is stored into the block pointed to by
 672 + * MCU_data[i].  WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
 673 + */
 674 +
 675 +/*
 676 + * MCU decoding for DC initial scan (either spectral selection,
 677 + * or first pass of successive approximation).
 678 + */
 679 +
 680 +METHODDEF(boolean)
 681 +decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 682 +{
 683 +  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
 684 +  JBLOCKROW block;
 685 +  unsigned char *st;
 686 +  int blkn, ci, tbl, sign;
 687 +  int v, m;
 688 +
 689 +  /* Process restart marker if needed */
 690 +  if (cinfo->restart_interval) {
 691 +    if (entropy->restarts_to_go == 0)
 692 +      process_restart(cinfo);
 693 +    entropy->restarts_to_go--;
 694 +  }
 695 +
 696 +  if (entropy->ct == -1) return TRUE;  /* if error do nothing */
 697 +
 698 +  /* Outer loop handles each block in the MCU */
 699 +
 700 +  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
 701 +    block = MCU_data[blkn];
 702 +    ci = cinfo->MCU_membership[blkn];
 703 +    tbl = cinfo->cur_comp_info[ci]->dc_tbl_no;
 704 +
 705 +    /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
 706 +
 707 +    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
 708 +    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
 709 +
 710 +    /* Figure F.19: Decode_DC_DIFF */
 711 +    if (arith_decode(cinfo, st) == 0)
 712 +      entropy->dc_context[ci] = 0;
 713 +    else {
 714 +      /* Figure F.21: Decoding nonzero value v */
 715 +      /* Figure F.22: Decoding the sign of v */
 716 +      sign = arith_decode(cinfo, st + 1);
 717 +      st += 2; st += sign;
 718 +      /* Figure F.23: Decoding the magnitude category of v */
 719 +      if ((m = arith_decode(cinfo, st)) != 0) {
 720 +       st = entropy->dc_stats[tbl] + 20;       /* Table F.4: X1 = 20 */
 721 +       while (arith_decode(cinfo, st)) {
 722 +         if ((m <<= 1) == 0x8000) {
 723 +           WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 724 +           entropy->ct = -1;                   /* magnitude overflow */
 725 +           return TRUE;
 726 +         }
 727 +         st += 1;
 728 +       }
 729 +      }
 730 +      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
 731 +      if (m < (int) (((INT32) 1 << cinfo->arith_dc_L[tbl]) >> 1))
 732 +       entropy->dc_context[ci] = 0;               /* zero diff category */
 733 +      else if (m > (int) (((INT32) 1 << cinfo->arith_dc_U[tbl]) >> 1))
 734 +       entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
 735 +      else
 736 +       entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
 737 +      v = m;
 738 +      /* Figure F.24: Decoding the magnitude bit pattern of v */
 739 +      st += 14;
 740 +      while (m >>= 1)
 741 +       if (arith_decode(cinfo, st)) v |= m;
 742 +      v += 1; if (sign) v = -v;
 743 +      entropy->last_dc_val[ci] += v;
 744 +    }
 745 +
 746 +    /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */
 747 +    (*block)[0] = (JCOEF) (entropy->last_dc_val[ci] << cinfo->Al);
 748 +  }
 749 +
 750 +  return TRUE;
 751 +}
 752 +
 753 +
 754 +/*
 755 + * MCU decoding for AC initial scan (either spectral selection,
 756 + * or first pass of successive approximation).
 757 + */
 758 +
 759 +METHODDEF(boolean)
 760 +decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 761 +{
 762 +  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
 763 +  JBLOCKROW block;
 764 +  unsigned char *st;
 765 +  int tbl, sign, k;
 766 +  int v, m;
 767 +
 768 +  /* Process restart marker if needed */
 769 +  if (cinfo->restart_interval) {
 770 +    if (entropy->restarts_to_go == 0)
 771 +      process_restart(cinfo);
 772 +    entropy->restarts_to_go--;
 773 +  }
 774 +
 775 +  if (entropy->ct == -1) return TRUE;  /* if error do nothing */
 776 +
 777 +  /* There is always only one block per MCU */
 778 +  block = MCU_data[0];
 779 +  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
 780 +
 781 +  /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
 782 +
 783 +  /* Figure F.20: Decode_AC_coefficients */
 784 +  for (k = cinfo->Ss; k <= cinfo->Se; k++) {
 785 +    st = entropy->ac_stats[tbl] + 3 * (k - 1);
 786 +    if (arith_decode(cinfo, st)) break;                /* EOB flag */
 787 +    while (arith_decode(cinfo, st + 1) == 0) {
 788 +      st += 3; k++;
 789 +      if (k > cinfo->Se) {
 790 +       WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 791 +       entropy->ct = -1;                       /* spectral overflow */
 792 +       return TRUE;
 793 +      }
 794 +    }
 795 +    /* Figure F.21: Decoding nonzero value v */
 796 +    /* Figure F.22: Decoding the sign of v */
 797 +    entropy->ac_stats[tbl][245] = 0;
 798 +    sign = arith_decode(cinfo, entropy->ac_stats[tbl] + 245);
 799 +    st += 2;
 800 +    /* Figure F.23: Decoding the magnitude category of v */
 801 +    if ((m = arith_decode(cinfo, st)) != 0) {
 802 +      if (arith_decode(cinfo, st)) {
 803 +       m <<= 1;
 804 +       st = entropy->ac_stats[tbl] +
 805 +            (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
 806 +       while (arith_decode(cinfo, st)) {
 807 +         if ((m <<= 1) == 0x8000) {
 808 +           WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 809 +           entropy->ct = -1;                   /* magnitude overflow */
 810 +           return TRUE;
 811 +         }
 812 +         st += 1;
 813 +       }
 814 +      }
 815 +    }
 816 +    v = m;
 817 +    /* Figure F.24: Decoding the magnitude bit pattern of v */
 818 +    st += 14;
 819 +    while (m >>= 1)
 820 +      if (arith_decode(cinfo, st)) v |= m;
 821 +    v += 1; if (sign) v = -v;
 822 +    /* Scale and output coefficient in natural (dezigzagged) order */
 823 +    (*block)[jpeg_natural_order[k]] = (JCOEF) (v << cinfo->Al);
 824 +  }
 825 +
 826 +  return TRUE;
 827 +}
 828 +
 829 +
 830 +/*
 831 + * MCU decoding for DC successive approximation refinement scan.
 832 + */
 833 +
 834 +METHODDEF(boolean)
 835 +decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 836 +{
 837 +  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
 838 +  unsigned char st[4];
 839 +  int p1, blkn;
 840 +
 841 +  /* Process restart marker if needed */
 842 +  if (cinfo->restart_interval) {
 843 +    if (entropy->restarts_to_go == 0)
 844 +      process_restart(cinfo);
 845 +    entropy->restarts_to_go--;
 846 +  }
 847 +
 848 +  p1 = 1 << cinfo->Al;         /* 1 in the bit position being coded */
 849 +
 850 +  /* Outer loop handles each block in the MCU */
 851 +
 852 +  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
 853 +    st[0] = 0; /* use fixed probability estimation */
 854 +    /* Encoded data is simply the next bit of the two's-complement DC value */
 855 +    if (arith_decode(cinfo, st))
 856 +      MCU_data[blkn][0][0] |= p1;
 857 +  }
 858 +
 859 +  return TRUE;
 860 +}
 861 +
 862 +
 863 +/*
 864 + * MCU decoding for AC successive approximation refinement scan.
 865 + */
 866 +
 867 +METHODDEF(boolean)
 868 +decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 869 +{
 870 +  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
 871 +  JBLOCKROW block;
 872 +  JCOEFPTR thiscoef;
 873 +  unsigned char *st;
 874 +  int tbl, k, kex;
 875 +  int p1, m1;
 876 +
 877 +  /* Process restart marker if needed */
 878 +  if (cinfo->restart_interval) {
 879 +    if (entropy->restarts_to_go == 0)
 880 +      process_restart(cinfo);
 881 +    entropy->restarts_to_go--;
 882 +  }
 883 +
 884 +  if (entropy->ct == -1) return TRUE;  /* if error do nothing */
 885 +
 886 +  /* There is always only one block per MCU */
 887 +  block = MCU_data[0];
 888 +  tbl = cinfo->cur_comp_info[0]->ac_tbl_no;
 889 +
 890 +  p1 = 1 << cinfo->Al;         /* 1 in the bit position being coded */
 891 +  m1 = (-1) << cinfo->Al;      /* -1 in the bit position being coded */
 892 +
 893 +  /* Establish EOBx (previous stage end-of-block) index */
 894 +  for (kex = cinfo->Se + 1; kex > 1; kex--)
 895 +    if ((*block)[jpeg_natural_order[kex - 1]]) break;
 896 +
 897 +  for (k = cinfo->Ss; k <= cinfo->Se; k++) {
 898 +    st = entropy->ac_stats[tbl] + 3 * (k - 1);
 899 +    if (k >= kex)
 900 +      if (arith_decode(cinfo, st)) break;      /* EOB flag */
 901 +    for (;;) {
 902 +      thiscoef = *block + jpeg_natural_order[k];
 903 +      if (*thiscoef) {                         /* previously nonzero coef */
 904 +       if (arith_decode(cinfo, st + 2))
 905 +         if (*thiscoef < 0)
 906 +           *thiscoef += m1;
 907 +         else
 908 +           *thiscoef += p1;
 909 +       break;
 910 +      }
 911 +      if (arith_decode(cinfo, st + 1)) {       /* newly nonzero coef */
 912 +       entropy->ac_stats[tbl][245] = 0;
 913 +       if (arith_decode(cinfo, entropy->ac_stats[tbl] + 245))
 914 +         *thiscoef = m1;
 915 +       else
 916 +         *thiscoef = p1;
 917 +       break;
 918 +      }
 919 +      st += 3; k++;
 920 +      if (k > cinfo->Se) {
 921 +       WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 922 +       entropy->ct = -1;                       /* spectral overflow */
 923 +       return TRUE;
 924 +      }
 925 +    }
 926 +  }
 927 +
 928 +  return TRUE;
 929 +}
 930 +
 931 +
 932 +/*
 933 + * Decode one MCU's worth of arithmetic-compressed coefficients.
 934 + */
 935 +
 936 +METHODDEF(boolean)
 937 +decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 938 +{
 939 +  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
 940 +  jpeg_component_info * compptr;
 941 +  JBLOCKROW block;
 942 +  unsigned char *st;
 943 +  int blkn, ci, tbl, sign, k;
 944 +  int v, m;
 945 +
 946 +  /* Process restart marker if needed */
 947 +  if (cinfo->restart_interval) {
 948 +    if (entropy->restarts_to_go == 0)
 949 +      process_restart(cinfo);
 950 +    entropy->restarts_to_go--;
 951 +  }
 952 +
 953 +  if (entropy->ct == -1) return TRUE;  /* if error do nothing */
 954 +
 955 +  /* Outer loop handles each block in the MCU */
 956 +
 957 +  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
 958 +    block = MCU_data[blkn];
 959 +    ci = cinfo->MCU_membership[blkn];
 960 +    compptr = cinfo->cur_comp_info[ci];
 961 +
 962 +    /* Sections F.2.4.1 & F.1.4.4.1: Decoding of DC coefficients */
 963 +
 964 +    tbl = compptr->dc_tbl_no;
 965 +
 966 +    /* Table F.4: Point to statistics bin S0 for DC coefficient coding */
 967 +    st = entropy->dc_stats[tbl] + entropy->dc_context[ci];
 968 +
 969 +    /* Figure F.19: Decode_DC_DIFF */
 970 +    if (arith_decode(cinfo, st) == 0)
 971 +      entropy->dc_context[ci] = 0;
 972 +    else {
 973 +      /* Figure F.21: Decoding nonzero value v */
 974 +      /* Figure F.22: Decoding the sign of v */
 975 +      sign = arith_decode(cinfo, st + 1);
 976 +      st += 2; st += sign;
 977 +      /* Figure F.23: Decoding the magnitude category of v */
 978 +      if ((m = arith_decode(cinfo, st)) != 0) {
 979 +       st = entropy->dc_stats[tbl] + 20;       /* Table F.4: X1 = 20 */
 980 +       while (arith_decode(cinfo, st)) {
 981 +         if ((m <<= 1) == 0x8000) {
 982 +           WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
 983 +           entropy->ct = -1;                   /* magnitude overflow */
 984 +           return TRUE;
 985 +         }
 986 +         st += 1;
 987 +       }
 988 +      }
 989 +      /* Section F.1.4.4.1.2: Establish dc_context conditioning category */
 990 +      if (m < (int) (((INT32) 1 << cinfo->arith_dc_L[tbl]) >> 1))
 991 +       entropy->dc_context[ci] = 0;               /* zero diff category */
 992 +      else if (m > (int) (((INT32) 1 << cinfo->arith_dc_U[tbl]) >> 1))
 993 +       entropy->dc_context[ci] = 12 + (sign * 4); /* large diff category */
 994 +      else
 995 +       entropy->dc_context[ci] = 4 + (sign * 4);  /* small diff category */
 996 +      v = m;
 997 +      /* Figure F.24: Decoding the magnitude bit pattern of v */
 998 +      st += 14;
 999 +      while (m >>= 1)
1000 +       if (arith_decode(cinfo, st)) v |= m;
1001 +      v += 1; if (sign) v = -v;
1002 +      entropy->last_dc_val[ci] += v;
1003 +    }
1004 +
1005 +    (*block)[0] = (JCOEF) entropy->last_dc_val[ci];
1006 +
1007 +    /* Sections F.2.4.2 & F.1.4.4.2: Decoding of AC coefficients */
1008 +
1009 +    tbl = compptr->ac_tbl_no;
1010 +
1011 +    /* Figure F.20: Decode_AC_coefficients */
1012 +    for (k = 1; k < DCTSIZE2; k++) {
1013 +      st = entropy->ac_stats[tbl] + 3 * (k - 1);
1014 +      if (arith_decode(cinfo, st)) break;      /* EOB flag */
1015 +      while (arith_decode(cinfo, st + 1) == 0) {
1016 +       st += 3; k++;
1017 +       if (k >= DCTSIZE2) {
1018 +         WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
1019 +         entropy->ct = -1;                     /* spectral overflow */
1020 +         return TRUE;
1021 +       }
1022 +      }
1023 +      /* Figure F.21: Decoding nonzero value v */
1024 +      /* Figure F.22: Decoding the sign of v */
1025 +      entropy->ac_stats[tbl][245] = 0;
1026 +      sign = arith_decode(cinfo, entropy->ac_stats[tbl] + 245);
1027 +      st += 2;
1028 +      /* Figure F.23: Decoding the magnitude category of v */
1029 +      if ((m = arith_decode(cinfo, st)) != 0) {
1030 +       if (arith_decode(cinfo, st)) {
1031 +         m <<= 1;
1032 +         st = entropy->ac_stats[tbl] +
1033 +              (k <= cinfo->arith_ac_K[tbl] ? 189 : 217);
1034 +         while (arith_decode(cinfo, st)) {
1035 +           if ((m <<= 1) == 0x8000) {
1036 +             WARNMS(cinfo, JWRN_ARITH_BAD_CODE);
1037 +             entropy->ct = -1;                 /* magnitude overflow */
1038 +             return TRUE;
1039 +           }
1040 +           st += 1;
1041 +         }
1042 +       }
1043 +      }
1044 +      v = m;
1045 +      /* Figure F.24: Decoding the magnitude bit pattern of v */
1046 +      st += 14;
1047 +      while (m >>= 1)
1048 +       if (arith_decode(cinfo, st)) v |= m;
1049 +      v += 1; if (sign) v = -v;
1050 +      (*block)[jpeg_natural_order[k]] = (JCOEF) v;
1051 +    }
1052 +  }
1053 +
1054 +  return TRUE;
1055 +}
1056 +
1057 +
1058 +/*
1059 + * Initialize for an arithmetic-compressed scan.
1060 + */
1061 +
1062 +METHODDEF(void)
1063 +start_pass (j_decompress_ptr cinfo)
1064 +{
1065 +  arith_entropy_ptr entropy = (arith_entropy_ptr) cinfo->entropy;
1066 +  int ci, tbl;
1067 +  jpeg_component_info * compptr;
1068 +
1069 +  if (cinfo->progressive_mode) {
1070 +    /* Validate progressive scan parameters */
1071 +    if (cinfo->Ss == 0) {
1072 +      if (cinfo->Se != 0)
1073 +       goto bad;
1074 +    } else {
1075 +      /* need not check Ss/Se < 0 since they came from unsigned bytes */
1076 +      if (cinfo->Se < cinfo->Ss || cinfo->Se >= DCTSIZE2)
1077 +       goto bad;
1078 +      /* AC scans may have only one component */
1079 +      if (cinfo->comps_in_scan != 1)
1080 +       goto bad;
1081 +    }
1082 +    if (cinfo->Ah != 0) {
1083 +      /* Successive approximation refinement scan: must have Al = Ah-1. */
1084 +      if (cinfo->Ah-1 != cinfo->Al)
1085 +       goto bad;
1086 +    }
1087 +    if (cinfo->Al > 13) {      /* need not check for < 0 */
1088 +      bad:
1089 +      ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
1090 +              cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
1091 +    }
1092 +    /* Update progression status, and verify that scan order is legal.
1093 +     * Note that inter-scan inconsistencies are treated as warnings
1094 +     * not fatal errors ... not clear if this is right way to behave.
1095 +     */
1096 +    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1097 +      int coefi, cindex = cinfo->cur_comp_info[ci]->component_index;
1098 +      int *coef_bit_ptr = & cinfo->coef_bits[cindex][0];
1099 +      if (cinfo->Ss && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
1100 +       WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
1101 +      for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
1102 +       int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
1103 +       if (cinfo->Ah != expected)
1104 +         WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
1105 +       coef_bit_ptr[coefi] = cinfo->Al;
1106 +      }
1107 +    }
1108 +    /* Select MCU decoding routine */
1109 +    if (cinfo->Ah == 0) {
1110 +      if (cinfo->Ss == 0)
1111 +       entropy->pub.decode_mcu = decode_mcu_DC_first;
1112 +      else
1113 +       entropy->pub.decode_mcu = decode_mcu_AC_first;
1114 +    } else {
1115 +      if (cinfo->Ss == 0)
1116 +       entropy->pub.decode_mcu = decode_mcu_DC_refine;
1117 +      else
1118 +       entropy->pub.decode_mcu = decode_mcu_AC_refine;
1119 +    }
1120 +  } else {
1121 +    /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
1122 +     * This ought to be an error condition, but we make it a warning because
1123 +     * there are some baseline files out there with all zeroes in these bytes.
1124 +     */
1125 +    if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
1126 +       cinfo->Ah != 0 || cinfo->Al != 0)
1127 +      WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
1128 +    /* Select MCU decoding routine */
1129 +    entropy->pub.decode_mcu = decode_mcu;
1130 +  }
1131 +
1132 +  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
1133 +    compptr = cinfo->cur_comp_info[ci];
1134 +    /* Allocate & initialize requested statistics areas */
1135 +    if (cinfo->progressive_mode == 0 || (cinfo->Ss == 0 && cinfo->Ah == 0)) {
1136 +      tbl = compptr->dc_tbl_no;
1137 +      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
1138 +       ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
1139 +      if (entropy->dc_stats[tbl] == NULL)
1140 +       entropy->dc_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
1141 +         ((j_common_ptr) cinfo, JPOOL_IMAGE, DC_STAT_BINS);
1142 +      MEMZERO(entropy->dc_stats[tbl], DC_STAT_BINS);
1143 +      /* Initialize DC predictions to 0 */
1144 +      entropy->last_dc_val[ci] = 0;
1145 +      entropy->dc_context[ci] = 0;
1146 +    }
1147 +    if (cinfo->progressive_mode == 0 || cinfo->Ss) {
1148 +      tbl = compptr->ac_tbl_no;
1149 +      if (tbl < 0 || tbl >= NUM_ARITH_TBLS)
1150 +       ERREXIT1(cinfo, JERR_NO_ARITH_TABLE, tbl);
1151 +      if (entropy->ac_stats[tbl] == NULL)
1152 +       entropy->ac_stats[tbl] = (unsigned char *) (*cinfo->mem->alloc_small)
1153 +         ((j_common_ptr) cinfo, JPOOL_IMAGE, AC_STAT_BINS);
1154 +      MEMZERO(entropy->ac_stats[tbl], AC_STAT_BINS);
1155 +    }
1156 +  }
1157 +
1158 +  /* Initialize arithmetic decoding variables */
1159 +  entropy->c = 0;
1160 +  entropy->a = 0;
1161 +  entropy->ct = -16;   /* force reading 2 initial bytes to fill C */
1162 +
1163 +  /* Initialize restart counter */
1164 +  entropy->restarts_to_go = cinfo->restart_interval;
1165 +}
1166 +
1167 +
1168 +/*
1169 + * Module initialization routine for arithmetic entropy decoding.
1170 + */
1171 +
1172 +GLOBAL(void)
1173 +jinit_arith_decoder (j_decompress_ptr cinfo)
1174 +{
1175 +  arith_entropy_ptr entropy;
1176 +  int i;
1177 +
1178 +  entropy = (arith_entropy_ptr)
1179 +    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
1180 +                               SIZEOF(arith_entropy_decoder));
1181 +  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
1182 +  entropy->pub.start_pass = start_pass;
1183 +
1184 +  /* Mark tables unallocated */
1185 +  for (i = 0; i < NUM_ARITH_TBLS; i++) {
1186 +    entropy->dc_stats[i] = NULL;
1187 +    entropy->ac_stats[i] = NULL;
1188 +  }
1189 +
1190 +  if (cinfo->progressive_mode) {
1191 +    /* Create progression status table */
1192 +    int *coef_bit_ptr, ci;
1193 +    cinfo->coef_bits = (int (*)[DCTSIZE2])
1194 +      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
1195 +                                 cinfo->num_components*DCTSIZE2*SIZEOF(int));
1196 +    coef_bit_ptr = & cinfo->coef_bits[0][0];
1197 +    for (ci = 0; ci < cinfo->num_components; ci++)
1198 +      for (i = 0; i < DCTSIZE2; i++)
1199 +       *coef_bit_ptr++ = -1;
1200 +  }
1201 +}
1202 diff --git a/jdmaster.c b/jdmaster.c
1203 index 8314b67..537abc7 100644
1204 --- a/jdmaster.c
1205 +++ b/jdmaster.c
1206 @@ -384,7 +384,7 @@ master_selection (j_decompress_ptr cinfo)
1207    jinit_inverse_dct(cinfo);
1208    /* Entropy decoding: either Huffman or arithmetic coding. */
1209    if (cinfo->arith_code) {
1210 -    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
1211 +    jinit_arith_decoder(cinfo);
1212    } else {
1213      if (cinfo->progressive_mode) {
1214  #ifdef D_PROGRESSIVE_SUPPORTED
1215 diff --git a/jdtrans.c b/jdtrans.c
1216 index 6c0ab71..fcc9ae9 100644
1217 --- a/jdtrans.c
1218 +++ b/jdtrans.c
1219 @@ -101,7 +101,7 @@ transdecode_master_selection (j_decompress_ptr cinfo)
1220
1221    /* Entropy decoding: either Huffman or arithmetic coding. */
1222    if (cinfo->arith_code) {
1223 -    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
1224 +    jinit_arith_decoder(cinfo);
1225    } else {
1226      if (cinfo->progressive_mode) {
1227  #ifdef D_PROGRESSIVE_SUPPORTED
1228 diff --git a/jerror.h b/jerror.h
1229 index fc2fffe..109e3d3 100644
1230 --- a/jerror.h
1231 +++ b/jerror.h
1232 @@ -93,6 +93,7 @@ JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data")
1233  JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change")
1234  JMESSAGE(JERR_NOTIMPL, "Not implemented yet")
1235  JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time")
1236 +JMESSAGE(JERR_NO_ARITH_TABLE, "Arithmetic table 0x%02x was not defined")
1237  JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported")
1238  JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined")
1239  JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image")
1240 @@ -170,6 +171,7 @@ JMESSAGE(JTRC_UNKNOWN_IDS,
1241  JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u")
1242  JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")
1243  JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d")
1244 +JMESSAGE(JWRN_ARITH_BAD_CODE, "Corrupt JPEG data: bad arithmetic code")
1245  JMESSAGE(JWRN_BOGUS_PROGRESSION,
1246          "Inconsistent progression sequence for component %d coefficient %d")
1247  JMESSAGE(JWRN_EXTRANEOUS_DATA,
1248 diff --git a/jmorecfg.h b/jmorecfg.h
1249 index 0e7fb72..4d66335 100644
1250 --- a/jmorecfg.h
1251 +++ b/jmorecfg.h
1252 @@ -283,7 +283,7 @@ typedef int boolean;
1253
1254  /* Decoder capability options: */
1255
1256 -#undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
1257 +#define D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
1258  #define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
1259  #define D_PROGRESSIVE_SUPPORTED            /* Progressive JPEG? (Requires MULTISCAN)*/
1260  #define SAVE_MARKERS_SUPPORTED     /* jpeg_save_markers() needed? */
1261 diff --git a/jpegint.h b/jpegint.h
1262 index 7a31f51..78bb1cf 100644
1263 --- a/jpegint.h
1264 +++ b/jpegint.h
1265 @@ -313,6 +313,7 @@ struct jpeg_color_quantizer {
1266  #define jinit_marker_reader    jIMReader
1267  #define jinit_huff_decoder     jIHDecoder
1268  #define jinit_phuff_decoder    jIPHDecoder
1269 +#define jinit_arith_decoder    jIADecoder
1270  #define jinit_inverse_dct      jIIDCT
1271  #define jinit_upsampler                jIUpsampler
1272  #define jinit_color_deconverter        jIDColor
1273 @@ -358,6 +359,7 @@ EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
1274  EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
1275  EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
1276  EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
1277 +EXTERN(void) jinit_arith_decoder JPP((j_decompress_ptr cinfo));
1278  EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
1279  EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
1280  EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
1281 --
1282 1.7.2.3
1283